Branch for working on the documentation tools documentation.

[SVN r68640]
Remove BOOST_ENABLE_ASSERT_MSG_HANDLER; use BOOST_ENABLE_ASSERT_HANDLER in its stead
2011-02-04 21:18:24 +00:00 · 2011-01-24 20:15:36 +00:00 · 2011-01-24 15:37:13 +00:00 · 2011-01-22 22:18:48 +00:00 · 2011-01-15 08:11:51 +00:00 · 2011-01-14 02:35:58 +00:00
157 changed files with 13324 additions and 8907 deletions
--- a/Assignable.html
+++ b/Assignable.html
@ -1,116 +1,109 @@
-<HTML>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <!--
  -- 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>
-<h3>Description</h3>
+<html>
-A type is Assignable if it is possible to assign one object of the type
+<head>
-to another object of that type.
+  <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>
+<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
-<Table>
+"#FF0000">
-<TR>
+  <img src="../../boost.png" alt="C++ Boost" width="277" height=
-<TD VAlign=top>
+  "86"><br clear="none">
 <tt>T</tt>
 </TD>
 <TD VAlign=top>
 is type that is a model of Assignable
 </TD>
 </TR>
-<TR>
+  <h1>Assignable</h1>
 <TD VAlign=top>
 <tt>t</tt>
 </TD>
 <TD VAlign=top>
 is an object of type <tt>T</tt>
 </TD>
 </tr>
-<TR>
+  <h3>Description</h3>
 <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>
-</table>
+  <p>A type is Assignable if it is possible to assign one object of the type
-<h3>Definitions</h3>
+  to another object of that type.</p>
 <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>
-</table>
+  <h3>Notation</h3>
  <table summary="">
    <tr>
      <td valign="top"><tt>T</tt></td>
-</table>
+      <td valign="top">is type that is a model of Assignable</td>
-<h3>Models</h3>
+    </tr>
-<UL>
+    <tr>
-<LI><tt>int</tt>
+      <td valign="top"><tt>t</tt></td>
 <LI><tt>std::pair</tt>
 </UL>
-<h3>See also</h3>
+      <td valign="top">is an object of type <tt>T</tt></td>
-<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</A>
+    </tr>
 and 
 <A href="./CopyConstructible.html">CopyConstructible</A>
-<br>
+    <tr>
-<HR>
+      <td valign="top"><tt>u</tt></td>
 <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>
-</BODY>
+      <td valign="top">is an object of type <tt>T</tt> or possibly <tt>const
-</HTML> 
+      T</tt></td>
    </tr>
  </table>
  <h3>Definitions</h3>
  <h3>Valid expressions</h3>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Return type</th>
      <th>Semantics</th>
    </tr>
    <tr>
      <td valign="top">Assignment</td>
      <td valign="top"><tt>t = u</tt></td>
      <td valign="top"><tt>T&amp;</tt></td>
      <td valign="top"><tt>t</tt> is equivalent to <tt>u</tt></td>
    </tr>
  </table>
  <h3>Models</h3>
  <ul>
    <li><tt>int</tt></li>
    <li><tt>std::pair</tt></li>
  </ul>
  <h3>See also</h3>
  <p><a href=
  "http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>
  and <a href="./CopyConstructible.html">CopyConstructible</a><br></p>
  <hr>
  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
  height="31" width="88"></a></p>
  <p>Revised 
  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
  <table summary="">
    <tr valign="top">
      <td nowrap><i>Copyright &copy; 2000</i></td>
      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
      Notre Dame (<a href=
      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
    </tr>
  </table>
  <p><i>Distributed under the Boost Software License, Version 1.0. (See
  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
  copy at <a href=
  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
 </body>
 </html>
--- a/Collection.html
+++ b/Collection.html
@ -0,0 +1,534 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
  <meta http-equiv="Content-Language" content="en-us">
  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
  <title>Collection</title>
 </head>
 <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 "#FF0000">
  <h1><img src="../../boost.png" alt="boost logo" width="277" align="middle"
  height="86"><br>
  Collection</h1>
  <h3>Description</h3>
  <p>A Collection is a <i>concept</i> similar to the STL <a href=
  "http://www.sgi.com/tech/stl/Container.html">Container</a> concept. A
  Collection provides iterators for accessing a range of elements and
  provides information about the number of elements in the Collection.
  However, a Collection has fewer requirements than a Container. The
  motivation for the Collection concept is that there are many useful
  Container-like types that do not meet the full requirements of Container,
  and many algorithms that can be written with this reduced set of
  requirements. To summarize the reduction in requirements:</p>
  <ul>
    <li>It is not required to "own" its elements: the lifetime of an element
    in a Collection does not have to match the lifetime of the Collection
    object, though the lifetime of the element should cover the lifetime of
    the Collection object.</li>
    <li>The semantics of copying a Collection object is not defined (it could
    be a deep or shallow copy or not even support copying).</li>
    <li>The associated reference type of a Collection does not have to be a
    real C++ reference.</li>
  </ul>Because of the reduced requirements, some care must be taken when
  writing code that is meant to be generic for all Collection types. In
  particular, a Collection object should be passed by-reference since
  assumptions can not be made about the behaviour of the copy constructor.
  <h3>Associated types</h3>
  <table border summary="">
    <tr>
      <td valign="top">Value type</td>
      <td valign="top"><tt>X::value_type</tt></td>
      <td valign="top">The type of the object stored in a Collection. If the
      Collection is <i>mutable</i> then the value type must be <a href=
      "http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>. Otherwise
      the value type must be <a href=
      "./CopyConstructible.html">CopyConstructible</a>.</td>
    </tr>
    <tr>
      <td valign="top">Iterator type</td>
      <td valign="top"><tt>X::iterator</tt></td>
      <td valign="top">The type of iterator used to iterate through a
      Collection's elements. The iterator's value type is expected to be the
      Collection's value type. A conversion from the iterator type to the
      const iterator type must exist. The iterator type must be an <a href=
      "http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.</td>
    </tr>
    <tr>
      <td valign="top">Const iterator type</td>
      <td valign="top"><tt>X::const_iterator</tt></td>
      <td valign="top">A type of iterator that may be used to examine, but
      not to modify, a Collection's elements.</td>
    </tr>
    <tr>
      <td valign="top">Reference type</td>
      <td valign="top"><tt>X::reference</tt></td>
      <td valign="top">A type that behaves like a reference to the
      Collection's value type. <a href="#n1">[1]</a></td>
    </tr>
    <tr>
      <td valign="top">Const reference type</td>
      <td valign="top"><tt>X::const_reference</tt></td>
      <td valign="top">A type that behaves like a const reference to the
      Collection's value type.</td>
    </tr>
    <tr>
      <td valign="top">Pointer type</td>
      <td valign="top"><tt>X::pointer</tt></td>
      <td valign="top">A type that behaves as a pointer to the Collection's
      value type.</td>
    </tr>
    <tr>
      <td valign="top">Distance type</td>
      <td valign="top"><tt>X::difference_type</tt></td>
      <td valign="top">A signed integral type used to represent the distance
      between two of the Collection's iterators. This type must be the same
      as the iterator's distance type.</td>
    </tr>
    <tr>
      <td valign="top">Size type</td>
      <td valign="top"><tt>X::size_type</tt></td>
      <td valign="top">An unsigned integral type that can represent any
      nonnegative value of the Collection's distance type.</td>
    </tr>
  </table>
  <h3>Notation</h3>
  <table summary="">
    <tr>
      <td valign="top"><tt>X</tt></td>
      <td valign="top">A type that is a model of Collection.</td>
    </tr>
    <tr>
      <td valign="top"><tt>a</tt>, <tt>b</tt></td>
      <td valign="top">Object of type <tt>X</tt>.</td>
    </tr>
    <tr>
      <td valign="top"><tt>T</tt></td>
      <td valign="top">The value type of <tt>X</tt>.</td>
    </tr>
  </table>
  <h3>Valid expressions</h3>
  <p>The following expressions must be valid.</p>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Return type</th>
    </tr>
    <tr>
      <td valign="top">Beginning of range</td>
      <td valign="top"><tt>a.begin()</tt></td>
      <td valign="top"><tt>iterator</tt> if <tt>a</tt> is mutable,
      <tt>const_iterator</tt> otherwise</td>
    </tr>
    <tr>
      <td valign="top">End of range</td>
      <td valign="top"><tt>a.end()</tt></td>
      <td valign="top"><tt>iterator</tt> if <tt>a</tt> is mutable,
      <tt>const_iterator</tt> otherwise</td>
    </tr>
    <tr>
      <td valign="top">Size</td>
      <td valign="top"><tt>a.size()</tt></td>
      <td valign="top"><tt>size_type</tt></td>
    </tr><!--
 <TR>
 <TD VAlign=top>
 Maximum size
 </TD>
 <TD VAlign=top>
 <tt>a.max_size()</tt>
 </TD>
 <TD VAlign=top>
 <tt>size_type</tt>
 </TD>
 </TR>
 -->
    <tr>
      <td valign="top">Empty Collection</td>
      <td valign="top"><tt>a.empty()</tt></td>
      <td valign="top">Convertible to <tt>bool</tt></td>
    </tr>
    <tr>
      <td valign="top">Swap</td>
      <td valign="top"><tt>a.swap(b)</tt></td>
      <td valign="top"><tt>void</tt></td>
    </tr>
  </table>
  <h3>Expression semantics</h3>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Semantics</th>
      <th>Postcondition</th>
    </tr>
    <tr>
      <td valign="top">Beginning of range</td>
      <td valign="top"><tt>a.begin()</tt></td>
      <td valign="top">Returns an iterator pointing to the first element in
      the Collection.</td>
      <td valign="top"><tt>a.begin()</tt> is either dereferenceable or
      past-the-end. It is past-the-end if and only if <tt>a.size() ==
      0</tt>.</td>
    </tr>
    <tr>
      <td valign="top">End of range</td>
      <td valign="top"><tt>a.end()</tt></td>
      <td valign="top">Returns an iterator pointing one past the last element
      in the Collection.</td>
      <td valign="top"><tt>a.end()</tt> is past-the-end.</td>
    </tr>
    <tr>
      <td valign="top">Size</td>
      <td valign="top"><tt>a.size()</tt></td>
      <td valign="top">Returns the size of the Collection, that is, its
      number of elements.</td>
      <td valign="top"><tt>a.size() &gt;= 0</tt></td>
    </tr><!--
 <TR>
 <TD VAlign=top>
 Maximum size
 </TD>
 <TD VAlign=top>
 <tt>a.max_size()</tt>
 </TD>
 <TD VAlign=top>
 &nbsp;
 </TD>
 <TD VAlign=top>
 Returns the largest size that this Collection can ever have. <A href="#8">[8]</A>
 </TD>
 <TD VAlign=top>
 <tt>a.max_size() &gt;= 0 &amp;&amp; a.max_size() &gt;= a.size()</tt>
 </TD>
 </TR>
 -->
    <tr>
      <td valign="top">Empty Collection</td>
      <td valign="top"><tt>a.empty()</tt></td>
      <td valign="top">Equivalent to <tt>a.size() == 0</tt>. (But possibly
      faster.)</td>
      <td valign="top">&nbsp;</td>
    </tr>
    <tr>
      <td valign="top">Swap</td>
      <td valign="top"><tt>a.swap(b)</tt></td>
      <td valign="top">Equivalent to <tt>swap(a,b)</tt></td>
      <td valign="top">&nbsp;</td>
    </tr>
  </table>
  <h3>Complexity guarantees</h3>
  <p><tt>begin()</tt> and <tt>end()</tt> are amortized constant time.</p>
  <p><tt>size()</tt> is at most linear in the Collection's size.
  <tt>empty()</tt> is amortized constant time.</p>
  <p><tt>swap()</tt> is at most linear in the size of the two
  collections.</p>
  <h3>Invariants</h3>
  <table border summary="">
    <tr>
      <td valign="top">Valid range</td>
      <td valign="top">For any Collection <tt>a</tt>, <tt>[a.begin(),
      a.end())</tt> is a valid range.</td>
    </tr>
    <tr>
      <td valign="top">Range size</td>
      <td valign="top"><tt>a.size()</tt> is equal to the distance from
      <tt>a.begin()</tt> to <tt>a.end()</tt>.</td>
    </tr>
    <tr>
      <td valign="top">Completeness</td>
      <td valign="top">An algorithm that iterates through the range
      <tt>[a.begin(), a.end())</tt> will pass through every element of
      <tt>a</tt>.</td>
    </tr>
  </table>
  <h3>Models</h3>
  <ul>
    <li><tt>array</tt></li>
    <li><tt>array_ptr</tt></li>
    <li><tt>vector&lt;bool&gt;</tt></li>
  </ul>
  <h3>Collection Refinements</h3>
  <p>There are quite a few concepts that refine the Collection concept,
  similar to the concepts that refine the Container concept. Here is a brief
  overview of the refining concepts.</p>
  <h4>ForwardCollection</h4>
  <p>The elements are arranged in some order that does not change
  spontaneously from one iteration to the next. As a result, a
  ForwardCollection is <a href=
  "http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>
  and <a href=
  "http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</a>.
  In addition, the iterator type of a ForwardCollection is a
  MultiPassInputIterator which is just an InputIterator with the added
  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 ForwardCollection also
  has a <tt>front()</tt> method.</p>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Return type</th>
      <th>Semantics</th>
    </tr>
    <tr>
      <td valign="top">Front</td>
      <td valign="top"><tt>a.front()</tt></td>
      <td valign="top"><tt>reference</tt> if <tt>a</tt> is mutable,<br>
      <tt>const_reference</tt> otherwise.</td>
      <td valign="top">Equivalent to <tt>*(a.begin())</tt>.</td>
    </tr>
  </table>
  <h4>ReversibleCollection</h4>
  <p>The container provides access to iterators that traverse in both
  directions (forward and reverse). The iterator type must meet all of the
  requirements of <a href=
  "http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>
  except that the reference type does not have to be a real C++ reference.
  The ReversibleCollection adds the following requirements to those of
  ForwardCollection.</p>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Return type</th>
      <th>Semantics</th>
    </tr>
    <tr>
      <td valign="top">Beginning of range</td>
      <td valign="top"><tt>a.rbegin()</tt></td>
      <td valign="top"><tt>reverse_iterator</tt> if <tt>a</tt> is mutable,
      <tt>const_reverse_iterator</tt> otherwise.</td>
      <td valign="top">Equivalent to
      <tt>X::reverse_iterator(a.end())</tt>.</td>
    </tr>
    <tr>
      <td valign="top">End of range</td>
      <td valign="top"><tt>a.rend()</tt></td>
      <td valign="top"><tt>reverse_iterator</tt> if <tt>a</tt> is mutable,
      <tt>const_reverse_iterator</tt> otherwise.</td>
      <td valign="top">Equivalent to
      <tt>X::reverse_iterator(a.begin())</tt>.</td>
    </tr>
    <tr>
      <td valign="top">Back</td>
      <td valign="top"><tt>a.back()</tt></td>
      <td valign="top"><tt>reference</tt> if <tt>a</tt> is mutable,<br>
      <tt>const_reference</tt> otherwise.</td>
      <td valign="top">Equivalent to <tt>*(--a.end())</tt>.</td>
    </tr>
  </table>
  <h4>SequentialCollection</h4>
  <p>The elements are arranged in a strict linear order. No extra methods are
  required.</p>
  <h4>RandomAccessCollection</h4>
  <p>The iterators of a RandomAccessCollection satisfy all of the
  requirements of <a href=
  "http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>
  except that the reference type does not have to be a real C++ reference. In
  addition, a RandomAccessCollection provides an element access operator.</p>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Return type</th>
      <th>Semantics</th>
    </tr>
    <tr>
      <td valign="top">Element Access</td>
      <td valign="top"><tt>a[n]</tt></td>
      <td valign="top"><tt>reference</tt> if <tt>a</tt> is mutable,
      <tt>const_reference</tt> otherwise.</td>
      <td valign="top">Returns the nth element of the Collection. <tt>n</tt>
      must be convertible to <tt>size_type</tt>. Precondition: <tt>0 &lt;= n
      &lt; a.size()</tt>.</td>
    </tr>
  </table>
  <h3>Notes</h3>
  <p><a name="n1" id="n1">[1]</a> The reference type does not have to be a
  real C++ reference. The requirements of the reference type depend on the
  context within which the Collection is being used. Specifically it depends
  on the requirements the context places on the value type of the Collection.
  The reference type of the Collection must meet the same requirements as the
  value type. In addition, the reference objects must be equivalent to the
  value type objects in the collection (which is trivially true if they are
  the same object). Also, in a mutable Collection, an assignment to the
  reference object must result in an assignment to the object in the
  Collection (again, which is trivially true if they are the same object, but
  non-trivial if the reference type is a proxy class).</p>
  <h3>See also</h3>
  <p><a href=
  "http://www.sgi.com/tech/stl/Container.html">Container</a><br></p>
  <hr>
  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
  height="31" width="88"></a></p>
  <p>Revised 
  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
  <table summary="">
    <tr valign="top">
      <td nowrap><i>Copyright &copy; 2000</i></td>
      <td><i><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy
      Siek</a>, Univ.of Notre Dame and C++ Library &amp; Compiler Group/SGI
      (<a href="mailto:jsiek@engr.sgi.com">jsiek@engr.sgi.com</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/CopyConstructible.html
+++ b/CopyConstructible.html
@ -1,178 +1,139 @@
-<HTML>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <!--
  -- 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>
-<h3>Description</h3>
+<html>
-A type is Copy Constructible if it is possible to copy objects of that
+<head>
-type.
+  <meta http-equiv="Content-Language" content="en-us">
  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-<h3>Notation</h3>
+  <title>Copy Constructible</title>
-<Table>
+</head>
 <TR>
 <TD VAlign=top>
 <tt>T</tt>
 </TD>
 <TD VAlign=top>
 is type that is a model of Copy Constructible
 </TD>
 </TR>
-<TR>
+<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
-<TD VAlign=top>
+"#FF0000">
-<tt>t</tt>
+  <img src="../../boost.png" alt="C++ Boost" width="277" height=
-</TD>
+  "86"><br clear="none">
 <TD VAlign=top>
 is an object of type <tt>T</tt>
 </TD>
 </tr>
-<TR>
+  <h1>Copy Constructible</h1>
 <TD VAlign=top>
 <tt>u</tt>
 </TD>
 <TD VAlign=top>
 is an object of type <tt>const T</tt>
 </TD>
 </tr>
-</table>
+  <h3>Description</h3>
 <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>
  <p>A type is Copy Constructible if it is possible to copy objects of that
  type.</p>
-<TR>
+  <h3>Notation</h3>
-<TD VAlign=top>
+
-Copy constructor
+  <table summary="">
-</TD>
+    <tr>
-<TD VAlign=top>
+      <td valign="top"><tt>T</tt></td>
-<pre>
+
      <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>
 <TD VAlign=top>
 <tt>T</tt>
 </TD>
 <TD VAlign=top>
 <tt>u</tt> is equivalent to <tt>T(u)</tt>
 </TD>
 </TR>
      <td valign="top"><tt>T</tt></td>
-<TR>
+      <td valign="top"><tt>u</tt> is equivalent to <tt>T(u)</tt></td>
-<TD VAlign=top>
+    </tr>
-Destructor
+
-</TD>
+    <tr>
-<TD VAlign=top>
+      <td valign="top">Destructor</td>
-<pre>
+
      <td valign="top">
        <pre>
 t.~T()
 </pre>
-</TD>
+      </td>
 <TD VAlign=top>
 <tt>T</tt>
 </TD>
 <TD VAlign=top>
 &nbsp;
 </TD>
 </TR>
-<TR>
+      <td valign="top"><tt>T</tt></td>
-<TD VAlign=top>
+
-Address Operator
+      <td valign="top">&nbsp;</td>
-</TD>
+    </tr>
-<TD VAlign=top>
+
-<pre>
+    <tr>
      <td valign="top">Address Operator</td>
      <td valign="top">
        <pre>
 &amp;t
 </pre>
-</TD>
+      </td>
 <TD VAlign=top>
 <tt>T*</tt>
 </TD>
 <TD VAlign=top>
 denotes the address of <tt>t</tt>
 </TD>
 </TR>
-<TR>
+      <td valign="top"><tt>T*</tt></td>
-<TD VAlign=top>
+
-Address Operator
+      <td valign="top">denotes the address of <tt>t</tt></td>
-</TD>
+    </tr>
-<TD VAlign=top>
+
-<pre>
+    <tr>
      <td valign="top">Address Operator</td>
      <td valign="top">
        <pre>
 &amp;u
 </pre>
-</TD>
+      </td>
 <TD VAlign=top>
 <tt>T*</tt>
 </TD>
 <TD VAlign=top>
 denotes the address of <tt>u</tt>
 </TD>
 </TR>
      <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>
+    <li><tt>std::pair</tt></li>
-<h3>Models</h3>
+  </ul>
-<UL>
+  <h3>Concept Checking Class</h3>
-<LI><tt>int</tt>
+  <pre>
 <LI><tt>std::pair</tt>
 </UL>
 <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>
+  <h3>See also</h3>
 <A
 href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</A>
 and 
 <A hrefa="./Assignable.html">Assignable</A>
-<br>
+  <p><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
-<HR>
+  Constructible</a> and <a href="./Assignable.html">Assignable</a><br></p>
-<TABLE>
+  <hr>
 <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>
-</BODY>
+  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
-</HTML> 
+  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
  height="31" width="88"></a></p>
  <p>Revised 
  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
  <table summary="">
    <tr valign="top">
      <td nowrap><i>Copyright &copy; 2000</i></td>
      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
      Notre Dame (<a href=
      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
    </tr>
  </table>
  <p><i>Distributed under the Boost Software License, Version 1.0. (See
  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
  copy at <a href=
  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
 </body>
 </html>
--- a/LessThanComparable.html
+++ b/LessThanComparable.html
@ -1,212 +1,210 @@
-<HTML>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
+  == 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,
+  == Permission to use, copy, modify, distribute and sell this software
-  -- provided that the above copyright notice appears in all copies and
+  == and its documentation for any purpose is hereby granted without fee,
-  -- that both that copyright notice and this permission notice appear
+  == provided that the above copyright notice appears in all copies and
-  -- in supporting documentation.  Silicon Graphics makes no
+  == that both that copyright notice and this permission notice appear
-  -- representations about the suitability of this software for any
+  == in supporting documentation.  Silicon Graphics makes no
-  -- purpose.  It is provided "as is" without express or implied warranty.
+  == 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>
+<head>
-A type is LessThanComparable if it is ordered: it must
+  <meta http-equiv="Content-Language" content="en-us">
-be possible to compare two objects of that type using <tt>operator&lt;</tt>, and
+  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
 <tt>operator&lt;</tt> must be a strict weak ordering relation.
  <title>LessThanComparable</title>
 </head>
-<h3>Refinement of</h3>
+<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
-<h3>Associated types</h3>
+"#FF0000">
-<h3>Notation</h3>
+  <img src="../../boost.png" alt="C++ Boost" width="277" height=
-<Table>
+  "86"><br clear="none">
 <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>
  <h1>LessThanComparable</h1>
  <h3>Description</h3>
-<h3>Expression semantics</h3>
+  <p>A type is LessThanComparable if it is ordered: it must be possible to
-<Table border>
+  compare two objects of that type using <tt>operator&lt;</tt>, and
-<TR>
+  <tt>operator&lt;</tt> must be a strict weak ordering relation.</p>
 <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>
  <h3>Refinement of</h3>
-<h3>Complexity guarantees</h3>
+  <h3>Associated types</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>Notation</h3>
  <table summary="">
    <tr>
      <td valign="top"><tt>X</tt></td>
-<br>
+      <td valign="top">A type that is a model of LessThanComparable</td>
-<HR>
+    </tr>
 <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>
-</BODY>
+    <tr>
-</HTML> 
+      <td valign="top"><tt>x</tt>, <tt>y</tt>, <tt>z</tt></td>
      <td valign="top">Object of type <tt>X</tt></td>
    </tr>
  </table>
  <h3>Definitions</h3>
  <p>Consider the relation <tt>!(x &lt; y) &amp;&amp; !(y &lt; x)</tt>. If
  this relation is transitive (that is, if <tt>!(x &lt; y) &amp;&amp; !(y
  &lt; x) &amp;&amp; !(y &lt; z) &amp;&amp; !(z &lt; y)</tt> implies <tt>!(x
  &lt; z) &amp;&amp; !(z &lt; x)</tt>), then it satisfies the mathematical
  definition of an equivalence relation. In this case, <tt>operator&lt;</tt>
  is a <i>strict weak ordering</i>.</p>
  <p>If <tt>operator&lt;</tt> is a strict weak ordering, and if each
  equivalence class has only a single element, then <tt>operator&lt;</tt> is
  a <i>total ordering</i>.</p>
  <h3>Valid expressions</h3>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Type requirements</th>
      <th>Return type</th>
    </tr>
    <tr>
      <td valign="top">Less</td>
      <td valign="top"><tt>x &lt; y</tt></td>
      <td valign="top">&nbsp;</td>
      <td valign="top">Convertible to <tt>bool</tt></td>
    </tr>
  </table>
  <h3>Expression semantics</h3>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Precondition</th>
      <th>Semantics</th>
      <th>Postcondition</th>
    </tr>
    <tr>
      <td valign="top">Less</td>
      <td valign="top"><tt>x &lt; y</tt></td>
      <td valign="top"><tt>x</tt> and <tt>y</tt> are in the domain of
      <tt>&lt;</tt></td>
      <td valign="top">&nbsp;</td>
    </tr>
  </table>
  <h3>Complexity guarantees</h3>
  <h3>Invariants</h3>
  <table border summary="">
    <tr>
      <td valign="top">Irreflexivity</td>
      <td valign="top"><tt>x &lt; x</tt> must be false.</td>
    </tr>
    <tr>
      <td valign="top">Antisymmetry</td>
      <td valign="top"><tt>x &lt; y</tt> implies !(y &lt; x) <a href=
      "#n2">[2]</a></td>
    </tr>
    <tr>
      <td valign="top">Transitivity</td>
      <td valign="top"><tt>x &lt; y</tt> and <tt>y &lt; z</tt> implies <tt>x
      &lt; z</tt> <a href="#n3">[3]</a></td>
    </tr>
  </table>
  <h3>Models</h3>
  <ul>
    <li>int</li>
  </ul>
  <h3>Notes</h3>
  <p><a name="n1" id="n1">[1]</a> Only <tt>operator&lt;</tt> is fundamental;
  the other inequality operators are essentially syntactic sugar.</p>
  <p><a name="n2" id="n2">[2]</a> Antisymmetry is a theorem, not an axiom: it
  follows from irreflexivity and transitivity.</p>
  <p><a name="n3" id="n3">[3]</a> Because of irreflexivity and transitivity,
  <tt>operator&lt;</tt> always satisfies the definition of a <i>partial
  ordering</i>. The definition of a <i>strict weak ordering</i> is stricter,
  and the definition of a <i>total ordering</i> is stricter still.</p>
  <h3>See also</h3>
  <p><a href=
  "http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>,
  <a href=
  "http://www.sgi.com/tech/stl/StrictWeakOrdering.html">StrictWeakOrdering</a><br>
  </p>
  <hr>
  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
  height="31" width="88"></a></p>
  <p>Revised 
  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
  December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
  <table summary="">
    <tr valign="top">
      <td nowrap><i>Copyright &copy; 2000</i></td>
      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
      Notre Dame (<a href=
      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
    </tr>
  </table>
  <p><i>Distributed under the Boost Software License, Version 1.0. (See
  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
  copy at <a href=
  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
 </body>
 </html>
--- a/MultiPassInputIterator.html
+++ b/MultiPassInputIterator.html
@ -1,92 +1,95 @@
-<HTML>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <!--
  -- 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"> 
-<BR Clear>
+<html>
 <head>
  <meta http-equiv="Content-Language" content="en-us">
  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-<H2>
+  <title>MultiPassInputIterator</title>
-<A NAME="concept:MultiPassInputIterator"></A>
+</head>
 Multi-Pass Input Iterator
 </H2>
-This concept is a refinement of <a
+<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
-href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
+"#FF0000">
-adding the requirements that the iterator can be used to make multiple
+  <img src="../../boost.png" alt="C++ Boost" width="277" height=
-passes through a range, and that if <TT>it1 == it2</TT> and
+  "86"><br clear="none">
 <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>.
  <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
+  <p>comments by Valentin Bonnard:</p>
 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> The terms Forward, Bidirectionnal and Random Access are about
+  <p>I think that introducing Multi-Pass Input Iterator isn't the right
-movabillity and shouldn't be used to mean anything else.  In a
+  solution. Do you also want to define Multi-Pass Bidirectionnal Iterator and
-completly orthogonal way, iterators can be immutable, mutable, or
+  Multi-Pass Random Access Iterator ? I don't, definitly. It only confuses
-neither.  Lvalueness of iterators is also orthogonal with
+  the issue. The problem lies into the existing hierarchy of iterators, which
-immutabillity.  With these clean concepts, your Multi-Pass Input Iterator
+  mixes movabillity, modifiabillity and lvalue-ness, and these are clearly
-is just called a Forward Iterator.
+  independant.</p>
-<p>                
+  <p>The terms Forward, Bidirectionnal and Random Access are about
-Other translations are:<br>
+  movabillity and shouldn't be used to mean anything else. In a completly
-std::Forward Iterator -> ForwardIterator & Lvalue Iterator<br>
+  orthogonal way, iterators can be immutable, mutable, or neither. Lvalueness
-std::Bidirectionnal Iterator -> Bidirectionnal Iterator & Lvalue Iterator<br>
+  of iterators is also orthogonal with immutabillity. With these clean
-std::Random Access Iterator -> Random Access Iterator & Lvalue Iterator<br>
+  concepts, your Multi-Pass Input Iterator is just called a Forward
  Iterator.</p>
-<p>
+  <p>Other translations are:<br>
-Note that in practice the only operation not allowed on my 
+  std::Forward Iterator -&gt; ForwardIterator &amp; Lvalue Iterator<br>
-Forward Iterator which is allowed on std::Forward Iterator is 
+  std::Bidirectionnal Iterator -&gt; Bidirectionnal Iterator &amp; Lvalue
-<tt>&*it</tt>. I think that <tt>&*</tt> is rarely needed in generic code.
+  Iterator<br>
  std::Random Access Iterator -&gt; Random Access Iterator &amp; Lvalue
  Iterator<br></p>
-<p>
+  <p>Note that in practice the only operation not allowed on my Forward
-reply by Jeremy Siek:
+  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>
+  <p>reply by Jeremy Siek:</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>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>
+  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
-<HR>
+  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
-<TABLE>
+  height="31" width="88"></a></p>
 <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>
-</BODY>
+  <p>Revised 
-</HTML> 
+  <!--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
@ -0,0 +1,164 @@
 <HTML>
 <Head>
 <Title>OptionalPointee Concept</Title>
 </HEAD>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
 <IMG SRC="../../boost.png" 
     ALT="C++ Boost" width="277" height="86"> 
 <!--end header-->
 <BR Clear>
 <H1>Concept: OptionalPointee</H1>
 <h3>Description</h3>
 A type is a model of <i>OptionalPointee</i> if it points to (or refers to) a value 
 that may not exist. That is, if it has a <b>pointee</b> which might be <b>valid</b>
 (existent) or <b>invalid</b> (inexistent); and it is possible to test whether the 
 pointee is valid or not.
 This model does <u>not</u> imply pointer semantics: i.e., it does not imply shallow copy nor
 aliasing.
 <h3>Notation</h3>
 <Table>
  <TR>
    <TD VAlign=top> <tt>T</tt> </TD>
    <TD VAlign=top> is a type that is a model of OptionalPointee</TD>
  </TR>
  <TR>
    <TD VAlign=top> <tt>t</tt> </TD>
    <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>
  <TR>
    <TH> Name </TH>
    <TH> Expression </TH>
    <TH> Return type </TH>
    <TH> Semantics </TH>
  </TR>
  <TR>
    <TD VAlign=top>Value Access</TD>
    <TD VAlign=top>&nbsp;<tt>*t</tt></TD>
    <TD VAlign=top>&nbsp;<tt>T&amp;</tt></TD>
    <TD VAlign=top>If the pointee is valid returns a reference to
      the pointee.<br>
      If the pointee is invalid the result is <i>undefined</i>.</TD>
    <TD VAlign=top> </TD>
  </TR>
  <TR>
    <TD VAlign=top>Value Access</TD>
    <TD VAlign=top>&nbsp;<tt>t-><i>xyz</i></tt></TD>
    <TD VAlign=top>&nbsp;<tt>T*</tt></TD>
    <TD VAlign=top>If the pointee is valid returns a builtin pointer to the pointee.<br>
      If the pointee is invalid the result is <i>undefined</i> (It might not even return NULL).<br>
    </TD>
    <TD VAlign=top> </TD>
  </TR>
  <TR>
    <TD VAlign=top>Validity Test</TD>
    <TD VAlign=top>&nbsp;<tt>t</tt><br>
     &nbsp;<tt>t != 0</tt><br>
     &nbsp;<tt>!!t</tt>
     </TD>
    <TD VAlign=top>&nbsp;bool </TD>
    <TD VAlign=top>If the pointee is valid returns true.<br>
      If the pointee is invalid returns false.</TD>
    <TD VAlign=top></TD>
  </TR>
  <TR>
    <TD VAlign=top>Invalidity Test</TD>
    <TD VAlign=top>&nbsp;<tt>t == 0</tt><br>
                   &nbsp;<tt>!t</tt>
    </TD>
    <TD VAlign=top>&nbsp;bool </TD>
    <TD VAlign=top>If the pointee is valid returns false.<br>
      If the pointee is invalid returns true.</TD>
    <TD VAlign=top></TD>
  </TR>
 </table>
 <h3>Models</h3>
 <UL>
  <LI><tt>pointers, both builtin and smart.</tt>
  <LI><tt>boost::optional&lt;&gt;</tt>
 </UL>
 <HR>
 <h3>OptionalPointee and relational operations</h3>
 <p>This concept does not define any particular semantic for relational operations, therefore,
 a type which models this concept might have either shallow or deep relational semantics.<br>
 For instance, pointers, which are models of OptionalPointee, have shallow relational operators:
 comparisons of pointers do not involve comparisons of pointees.
 This makes sense for pointers because they have shallow copy semantics.<br>
 But boost::optional&lt;T&gt;, on the other hand, which is also a model of OptionalPointee, has
 deep-copy and deep-relational semantics.<br>
 If generic code is written for this concept, it is important not to use relational
 operators directly because the semantics might be different depending on the actual type.<br>
 Still, the concept itsef can be used to define <i>deep</i> relational tests that can
 be used in generic code with any type which models OptionalPointee:</p>
 <a name="equal"></a>
 <p><u>Equivalence relation:</u></p>
 <pre>template&lt;class OptionalPointee&gt;
 inline
 bool equal_pointees ( OptionalPointee const&amp; x, OptionalPointee const&amp; y )
 {
  return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
 }
 template&lt;class OptionalPointee&gt;
 struct equal_pointees_t : std::binary_function&lt;OptionalPointee,OptionalPointee,bool&gt;
 {
  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return equal_pointees(x,y) ; }
 } ;
 </pre>
 <p>The preceding generic function and function object have the following semantics:<br>
 If both <b>x</b> and <b>y</b> have valid pointees, it compares values via <code>(*x == *y)</code>.<br>
 If only one has a valid pointee, returns <code>false</code>.<br>
 If both have invalid pointees, returns <code>true</code>.</p>
 <a name="less"></a>
 <p><u>Less-than relation:</u></p>
 <pre>template&lt;class OptionalPointee&gt;
 inline
 bool less_pointees ( OptionalPointee const&amp; x, OptionalPointee const&amp; y )
 {
  return !y ? false : ( !x ? true : (*x) < (*y) ) ;
 }
 template&lt;class OptionalPointee&gt;
 struct less_pointees_t : std::binary_function&lt;OptionalPointee,OptionalPointee,bool&gt;
 {
  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return less_pointees(x,y) ; }
 } ;
 </pre>
 <p>The preceding generic function and function object have the following semantics:<br>
 If <b>y</b> has an invalid pointee, returns <code>false</code>.<br>
 Else, if <b>x</b> has an invalid pointee, returns <code>true</code>.<br>
 Else, ( <b>x</b> and <b>y</b> have valid pointees), compares values via <code>(*x &lt; 
 *y).</code></p>
 <p><br>
 All these functions and function 
 objects are is implemented in <a href="../../boost/utility/compare_pointees.hpp">compare_pointees.hpp</a></p>
 <p>Notice that OptionalPointee does not imply aliasing (and optional&lt;&gt; for instance does not alias);
 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>
 </TD></TR></TABLE>
 <p>Distributed under the Boost Software License, Version 1.0. See
 <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
 </BODY>
 </HTML>
--- a/addressof_fn_test.cpp
+++ b/addressof_fn_test.cpp
@ -0,0 +1,76 @@
 #include <boost/config.hpp>
 #if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
 #pragma warning(disable: 4514)  // unreferenced inline removed
 #endif
 //  addressof_fn_test.cpp: addressof( f )
 //
 //  Copyright (c) 2008, 2009 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 #include <boost/utility/addressof.hpp>
 #include <boost/detail/lightweight_test.hpp>
 void f0()
 {
 }
 void f1(int)
 {
 }
 void f2(int, int)
 {
 }
 void f3(int, int, int)
 {
 }
 void f4(int, int, int, int)
 {
 }
 void f5(int, int, int, int, int)
 {
 }
 void f6(int, int, int, int, int, int)
 {
 }
 void f7(int, int, int, int, int, int, int)
 {
 }
 void f8(int, int, int, int, int, int, int, int)
 {
 }
 void f9(int, int, int, int, int, int, int, int, int)
 {
 }
 int main()
 {
    BOOST_TEST( boost::addressof( f0 ) == &f0 );
    BOOST_TEST( boost::addressof( f1 ) == &f1 );
    BOOST_TEST( boost::addressof( f2 ) == &f2 );
    BOOST_TEST( boost::addressof( f3 ) == &f3 );
    BOOST_TEST( boost::addressof( f4 ) == &f4 );
    BOOST_TEST( boost::addressof( f5 ) == &f5 );
    BOOST_TEST( boost::addressof( f6 ) == &f6 );
    BOOST_TEST( boost::addressof( f7 ) == &f7 );
    BOOST_TEST( boost::addressof( f8 ) == &f8 );
    BOOST_TEST( boost::addressof( f9 ) == &f9 );
    return boost::report_errors();
 }
--- a/addressof_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
+// Distributed under the Boost Software License, Version 1.0. (See
-// provided this copyright notice appears in all copies.
+// accompanying file LICENSE_1_0.txt or copy at
-// Permission to modify the code and to distribute modified code is granted
+// http://www.boost.org/LICENSE_1_0.txt)
 // 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.
 // For more information, see http://www.boost.org
-#define BOOST_INCLUDE_MAIN
+
-#include <boost/test/test_tools.hpp>
+#include <boost/utility/addressof.hpp>
-#include <boost/utility.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;
+    array_test<char>();
-  BOOST_TEST(boost::addressof(x) == px);
+    array_test<int>();
    array_test<addressable>();
    array_test<nonaddressable>();
-  const nonaddressable& cx = *px;
+    return boost::report_errors();
  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;
 }
--- a/addressof_test2.cpp
+++ b/addressof_test2.cpp
@ -0,0 +1,95 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
 //                    Douglas Gregor (gregod@cs.rpi.edu)
 //
 // Copyright 2009 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // For more information, see http://www.boost.org
 #include <boost/utility/addressof.hpp>
 #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
 #pragma warning(push, 3)
 #endif
 #include <iostream>
 #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
 #pragma warning(pop)
 #endif
 #include <boost/detail/lightweight_test.hpp>
 template<class T> void scalar_test( T * = 0 )
 {
    T* px = new T();
    T& x = *px;
    BOOST_TEST( boost::addressof(x) == px );
    const T& cx = *px;
    const T* pcx = boost::addressof(cx);
    BOOST_TEST( pcx == px );
    volatile T& vx = *px;
    volatile T* pvx = boost::addressof(vx);
    BOOST_TEST( pvx == px );
    const volatile T& cvx = *px;
    const volatile T* pcvx = boost::addressof(cvx);
    BOOST_TEST( pcvx == px );
    delete px;
 }
 template<class T> void array_test( T * = 0 )
 {
    T nrg[3] = {1,2,3};
    T (*pnrg)[3] = &nrg;
    BOOST_TEST( boost::addressof(nrg) == pnrg );
    T const cnrg[3] = {1,2,3};
    T const (*pcnrg)[3] = &cnrg;
    BOOST_TEST( boost::addressof(cnrg) == pcnrg );
 }
 class convertible {
 public:
    convertible( int = 0 )
    {
    }
    template<class U> operator U () const
    {
        return U();
    }
 };
 class convertible2 {
 public:
    convertible2( int = 0 )
    {
    }
    operator convertible2* () const
    {
        return 0;
    }
 };
 int main()
 {
    scalar_test<convertible>();
    scalar_test<convertible2>();
    array_test<convertible>();
    array_test<convertible2>();
    return boost::report_errors();
 }
--- a/assert.html
+++ b/assert.html
@ -0,0 +1,115 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <html>
 	<head>
 		<title>Boost: assert.hpp documentation</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
 		<table border="0" width="100%">
 			<tr>
 				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
 				</td>
 				<td align="center">
 					<h1>assert.hpp</h1>
 				</td>
 			</tr>
 			<tr>
 				<td colspan="2" height="64">&nbsp;</td>
 			</tr>
 		</table>
 		<p>
 			<a href="#BOOST_ASSERT">BOOST_ASSERT</a><br>
            <a href="#BOOST_ASSERT_MSG">BOOST_ASSERT_MSG</a><br>
            <a href="#BOOST_VERIFY">BOOST_VERIFY</a></p>
 <h2><a name="BOOST_ASSERT">BOOST_ASSERT</a></h2>
 		<p>
 			The header <STRONG>&lt;boost/assert.hpp&gt;</STRONG> defines the macro <b>BOOST_ASSERT</b>, 
 			which is similar to the standard <STRONG>assert</STRONG> macro defined in <STRONG>&lt;cassert&gt;</STRONG>. 
 			The macro is intended to be used in both Boost libraries and user 
            code.
 		</p>
 		<P>By default, <tt>BOOST_ASSERT(expr)</tt> is equivalent to <tt>assert(expr)</tt>.</P>
 		<P>If the macro <STRONG>BOOST_DISABLE_ASSERTS</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> is defined as <tt>((void)0)</tt>. This 
 			allows users to selectively disable <STRONG>BOOST_ASSERT</STRONG> without 
 			affecting the definition of the standard <STRONG>assert</STRONG>.</P>
 		<P>If the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> evaluates <b>expr</b> and, if the 
 			result is false, evaluates the expression</P>
 		<blockquote>
 		<P><tt>::boost::assertion_failed(#expr, <a href="current_function.html">BOOST_CURRENT_FUNCTION</a>, 
 				__FILE__, __LINE__)</tt></P>
 		</blockquote>
 		<P><STRONG>assertion_failed</STRONG> is declared in <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			as</P>
 		<blockquote>
 		<pre>namespace boost
 {
  void assertion_failed(char const * expr, char const * function, char const * file, long line);
 }
 </pre>
 		</blockquote>
 		<p>but it is never defined. The user is expected to supply an appropriate 
 			definition.</p>
 		<P>As is the case with <STRONG>&lt;cassert&gt;</STRONG>, <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			can be included multiple times in a single translation unit. <STRONG>BOOST_ASSERT</STRONG>
 			will be redefined each time as specified above.</P>
 <h2><a name="BOOST_ASSERT_MSG">BOOST_ASSERT_MSG</a></h2>
 		<p>
 			The header <STRONG>&lt;boost/assert.hpp&gt;</STRONG> defines the macro <b>BOOST_ASSERT_MSG</b>, 
 			which is similar to the standard <STRONG>assert</STRONG> macro defined in <STRONG>&lt;cassert&gt;</STRONG>, 
            but with an additional macro parameter supplying an error message. The macro is intended to be used in both Boost libraries 
            and user code.
 		</p>
 		<P> <tt>BOOST_ASSERT_MSG(expr, msg)</tt> is equivalent to <code>
        ((void)0)</code> if <b>BOOST_DISABLE_ASSERTS</b> or <b>NDEBUG</b> are 
        defined or <code>expr</code> evaluates to <code>true</code>. If those 
        macros and <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> are not 
        defined, and <code>expr</code> evaluates to <code>false</code>, an error 
        message that includes <tt>#expr</tt>, <tt>msg</tt>, <tt> <a href="current_function.html">BOOST_CURRENT_FUNCTION</a></tt>, <tt>
        __FILE__</tt>, and <tt>__LINE__</tt> is sent to output stream <b>
        BOOST_ASSERT_MSG_OSTREAM</b> 
        and <code>std::abort()</code> is called.</P>
 		<P> <b>BOOST_ASSERT_MSG_OSTREAM</b> defines the output stream. It defaults to <code>std::cerr</code>. 
        Integrated development environments (IDE's) like Microsoft Visual Studio 
        may produce easier to understand output if messages go to a different 
        stream, such as <code>std::cout</code>. Users may define <b>BOOST_ASSERT_MSG_OSTREAM</b> before including <STRONG>&lt;boost/assert.hpp&gt;</STRONG> 
        to specify a different output stream.&nbsp; </P>
 		<P>If the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, instead of sending a error message to an output 
        stream, this expression is evaluated</P>
 		<blockquote>
 		<P><tt>::boost::assertion_failed_msg(#expr, msg, <a href="current_function.html">BOOST_CURRENT_FUNCTION</a>, 
 				__FILE__, __LINE__)</tt></P>
 		</blockquote>
 		<P><STRONG>assertion_failed_msg</STRONG> is declared in <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			as</P>
 		<blockquote>
 		<pre>namespace boost
 {
  void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line);
 }
 </pre>
 		</blockquote>
 		<p>but it is never defined. The user is expected to supply an appropriate 
 			definition.</p>
 		<P>As is the case with <STRONG>&lt;cassert&gt;</STRONG>, <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			can be included multiple times in a single translation unit. <STRONG>BOOST_ASSERT_MSG</STRONG>
 			will be redefined each time as specified above.</P>
 <h2><a name="BOOST_VERIFY">BOOST_VERIFY</a></h2>
 		<p><STRONG>&lt;boost/assert.hpp&gt;</STRONG> also defines the macro <STRONG>BOOST_VERIFY</STRONG>. 
 			It has exactly the same behavior as <STRONG>BOOST_ASSERT</STRONG>, except that 
 			the expression that is passed to <STRONG>BOOST_VERIFY</STRONG> is always 
 			evaluated. This is useful when the asserted expression has desirable side 
 			effects; it can also help suppress warnings about unused variables when the 
 			only use of the variable is inside an assertion.</p>
 		<p><br>
 			<small>Copyright <20> 2002, 2007 by Peter Dimov.&nbsp; Copyright <20> 2011 
        by Beman Dawes. Distributed under the Boost Software 
 				License, Version 1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A>
 				or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
 </html>
--- a/assert_test.cpp
+++ b/assert_test.cpp
@ -1,33 +1,153 @@
 #if defined(_MSC_VER) && !defined(__ICL)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
 #pragma warning(disable: 4514)  // unreferenced inline removed
 #endif
 //
 //  assert_test.cpp - a test for boost/assert.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (2) Beman Dawes 2011
 //
-//  Permission to copy, use, modify, sell and distribute this software
+// Distributed under the Boost Software License, Version 1.0. (See
-//  is granted provided this copyright notice appears in all copies.
+// accompanying file LICENSE_1_0.txt or copy at
-//  This software is provided "as is" without express or implied
+// http://www.boost.org/LICENSE_1_0.txt)
 //  warranty, and with no claim as to its suitability for any purpose.
 //
-#define BOOST_DEBUG 1
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/assert.hpp>
 void test_default()
 {
    int x = 1;
    BOOST_ASSERT(1);
    BOOST_ASSERT(x);
    BOOST_ASSERT(x == 1);
    BOOST_ASSERT(&x);
    BOOST_ASSERT_MSG(1, "msg");
    BOOST_ASSERT_MSG(x, "msg");
    BOOST_ASSERT_MSG(x == 1, "msg");
    BOOST_ASSERT_MSG(&x, "msg");
 }
 #define BOOST_DISABLE_ASSERTS
 #include <boost/assert.hpp>
 void test_disabled()
 {
    int x = 1;
    BOOST_ASSERT(1);
    BOOST_ASSERT(x);
    BOOST_ASSERT(x == 1);
    BOOST_ASSERT(&x);
    BOOST_ASSERT_MSG(1, "msg");
    BOOST_ASSERT_MSG(x, "msg");
    BOOST_ASSERT_MSG(x == 1, "msg");
    BOOST_ASSERT_MSG(&x, "msg");
    BOOST_ASSERT(0);
    BOOST_ASSERT(!x);
    BOOST_ASSERT(x == 0);
    BOOST_ASSERT_MSG(0, "msg");
    BOOST_ASSERT_MSG(!x, "msg");
    BOOST_ASSERT_MSG(x == 0, "msg");
    void * p = 0;
    BOOST_ASSERT(p);
    BOOST_ASSERT_MSG(p, "msg");
    // supress warnings
    p = &x;
    p = &p;
 }
 #undef BOOST_DISABLE_ASSERTS
 #define BOOST_ENABLE_ASSERT_HANDLER
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <cstdio>
-bool boost_error(char const * expr, char const * func, char const * file, long line)
+int handler_invoked = 0;
 int msg_handler_invoked = 0;
 void boost::assertion_failed(char const * expr, char const * function, char const * file, long line)
 {
-    std::printf("%s(%ld): Assertion '%s' failed in function '%s'\n", file, line, expr, func);
+#if !defined(BOOST_NO_STDC_NAMESPACE)
-    return true; // fail w/ standard assert()
+    using std::printf;
 #endif
    printf("Expression: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n", expr, function, file, line);
    ++handler_invoked;
 }
 void boost::assertion_failed_msg(char const * expr, char const * msg, char const * function,
  char const * file, long line)
 {
 #if !defined(BOOST_NO_STDC_NAMESPACE)
    using std::printf;
 #endif
    printf("Expression: %s Message: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n",
      expr, msg, function, file, line);
    ++msg_handler_invoked;
 }
 struct X
 {
    static void f()
    {
        BOOST_ASSERT(0);
        BOOST_ASSERT_MSG(0, "msg f()");
    }
 };
 void test_handler()
 {
    int x = 1;
    BOOST_ASSERT(1);
    BOOST_ASSERT(x);
    BOOST_ASSERT(x == 1);
    BOOST_ASSERT(&x);
    BOOST_ASSERT_MSG(1, "msg2");
    BOOST_ASSERT_MSG(x, "msg3");
    BOOST_ASSERT_MSG(x == 1, "msg4");
    BOOST_ASSERT_MSG(&x, "msg5");
    BOOST_ASSERT(0);
    BOOST_ASSERT(!x);
    BOOST_ASSERT(x == 0);
    BOOST_ASSERT_MSG(0,"msg 0");
    BOOST_ASSERT_MSG(!x, "msg !x");
    BOOST_ASSERT_MSG(x == 0, "msg x == 0");
    void * p = 0;
    BOOST_ASSERT(p);
    BOOST_ASSERT_MSG(p, "msg p");
    X::f();
    BOOST_ASSERT(handler_invoked == 5);
    BOOST_TEST(handler_invoked == 5);
    BOOST_ASSERT_MSG(msg_handler_invoked == 5, "msg_handler_invoked count is wrong");
    BOOST_TEST(msg_handler_invoked == 5);
 }
 #undef BOOST_ENABLE_ASSERT_HANDLER
 #undef BOOST_ENABLE_ASSERT_MSG_HANDLER
 int main()
 {
-    BOOST_ASSERT(0 == 1);
+    test_default();
    test_disabled();
    test_handler();
    return boost::report_errors();
 }
--- 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>.
+which is included in <i><a href="../../boost/utility.hpp">boost/utility.hpp</a></i>.</p>
 The class template is forward declared in <i><a href="../../boost/utility_fwd.hpp">boost/utility_fwd.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>
@ -64,11 +63,12 @@ public:
 </pre></blockquote>
 <p>This is undefined because C++'s initialization order mandates that
-the base class is initialized before the member it uses.  Ron Klatchko
+the base class is initialized before the member it uses.  <a
-developed a way around this by using the initialization order in his
+href="http://www.moocat.org">R. Samuel Klatchko</a> developed a way
-favor.  Base classes are intialized in order of declaration, so moving
+around this by using the initialization order in his favor.  Base
-the desired member to another base class, that is initialized before the
+classes are intialized in order of declaration, so moving the desired
-desired base class, can ensure proper initialization.</p>
+member to another base class, that is initialized before the desired
 base class, can ensure proper initialization.</p>
 <p>A custom base class can be made for this idiom:</p>
@ -108,7 +108,13 @@ public:
 };
 </pre></blockquote>
-<p>Other projects can use similar custom base classes.  The technique is basic enough to make a template, with a sample template class in this library.  The main template parameter is the type of the enclosed member.  The template class has several (explicit) constructor member templates, which implicitly type the constructor arguments and pass them to the member.  The template class uses implicit copy construction and assignment, cancelling them if the enclosed member is non-copyable.</p>
+<p>Other projects can use similar custom base classes.  The technique
 is basic enough to make a template, with a sample template class in
 this library.  The main template parameter is the type of the enclosed
 member.  The template class has several (explicit) constructor member
 templates, which implicitly type the constructor arguments and pass them
 to the member.  The template class uses implicit copy construction and
 assignment, cancelling them if the enclosed member is non-copyable.</p>
 <p>Manually coding a base class may be better if the construction
 and/or copying needs are too complex for the supplied template class,
@ -123,21 +129,31 @@ 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
 {
 protected:
    MemberType  member;
-    explicit  base_from_member();
+    base_from_member();
    template&lt; typename T1 &gt;
    explicit  base_from_member( T1 x1 );
    template&lt; typename T1, typename T2 &gt;
    base_from_member( T1 x1, T2 x2 );
    //...
-    template&lt; typename T1, typename T2, typename T3 &gt;
+    template&lt; typename T1, typename T2, typename T3, typename T4,
-    explicit  base_from_member( T1 x1, T2 x2, T3 x3 );
+     typename T5, typename T6, typename T7, typename T8, typename T9,
     typename T10 &gt;
    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7,
     T8 x8, T9 x9, T10 x10 );
 };
 </pre></blockquote>
@ -152,12 +168,20 @@ for later base classes (or itself).</p>
 <p>There is a default constructor and several constructor member
 templates.  These constructor templates can take as many arguments
-(currently up to three) as possible and pass them to a constructor of
+(currently up to ten) as possible and pass them to a constructor of
 the data member.  Since C++ does not allow any way to explicitly state
 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
@ -310,32 +334,38 @@ 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>Ron Klatchko (<a href="mailto:ron@crl.com">ron@crl.com</a>)
+	<dt><a href="http://www.moocat.org">R. Samuel Klatchko</a> (<a
 	href="mailto:rsk@moocat.org">rsk@moocat.org</a>, <a
 	href="mailto:rsk@brightmail.com">rsk@brightmail.com</a>)
 	<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: 22 August 2001</p>
+<p>Revised: 28 August 2004</p>
-<p>Copyright &copy; boost.org 2001.  Permission to copy, use, modify,
+<p>Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and distribution
-sell and distribute this document is granted provided this copyright
+are subject to the Boost Software License, Version 1.0.  (See accompanying
-notice appears in all copies.  This document is provided &quot;as
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
-is&quot; without express or implied warranty, and with no claim as to
+href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
 its suitability for any purpose.</p>
 </body>
 </html>
--- a/base_from_member_test.cpp
+++ b/base_from_member_test.cpp
@ -1,22 +1,20 @@
 //  Boost test program for base-from-member class templates  -----------------//
-//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
+//  Copyright 2001, 2003 Daryle Walker.  Use, modification, and distribution are
-//  and distribute this software is granted provided this copyright
+//  subject to the Boost Software License, Version 1.0.  (See accompanying file
-//  notice appears in all copies.  This software is provided "as is" without
+//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
 //  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.
+//  See <http://www.boost.org/libs/utility/> for the library's home page.
 //  Revision History
 //  14 Jun 2003  Adjusted code for Boost.Test changes (Daryle Walker)
 //  29 Aug 2001  Initial Version (Daryle Walker)
-#define  BOOST_INCLUDE_MAIN
+#include <boost/test/minimal.hpp>  // for BOOST_CHECK, main
 #include <boost/test/test_tools.hpp>  // for BOOST_TEST, main
-#include <boost/config.hpp>   // for BOOST_NO_MEMBER_TEMPLATES
+#include <boost/config.hpp>       // for BOOST_NO_MEMBER_TEMPLATES
-#include <boost/cstdlib.hpp>  // for boost::exit_success
+#include <boost/cstdlib.hpp>      // for boost::exit_success
-#include <boost/utility.hpp>  // for boost::noncopyable
+#include <boost/noncopyable.hpp>  // for boost::noncopyable
 #include <boost/utility/base_from_member.hpp>  // for boost::base_from_member
@ -177,11 +175,11 @@ object_registrar  obj_reg;
 int
 test_main( int , char * [] )
 {
-    BOOST_TEST( obj_reg.db_.empty() );
+    BOOST_CHECK( obj_reg.db_.empty() );
-    BOOST_TEST( obj_reg.defrauders_in_.empty() );
+    BOOST_CHECK( obj_reg.defrauders_in_.empty() );
-    BOOST_TEST( obj_reg.defrauders_out_.empty() );
+    BOOST_CHECK( obj_reg.defrauders_out_.empty() );
-    BOOST_TEST( obj_reg.overeager_.empty() );
+    BOOST_CHECK( obj_reg.overeager_.empty() );
-    BOOST_TEST( obj_reg.overkilled_.empty() );
+    BOOST_CHECK( obj_reg.overkilled_.empty() );
    // Make a separate block to examine pre- and post-effects
    {
@ -189,20 +187,20 @@ test_main( int , char * [] )
        using std::endl;
        bad_class  bc;
-        BOOST_TEST( obj_reg.db_.size() == 3 );
+        BOOST_CHECK( obj_reg.db_.size() == 3 );
-        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
+        BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
        good_class_1  gc1;
-        BOOST_TEST( obj_reg.db_.size() == 6 );
+        BOOST_CHECK( obj_reg.db_.size() == 6 );
-        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
+        BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
        good_class_2  gc2;
-        BOOST_TEST( obj_reg.db_.size() == 11 );
+        BOOST_CHECK( obj_reg.db_.size() == 11 );
-        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
+        BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
-        BOOST_TEST( obj_reg.defrauders_out_.empty() );
+        BOOST_CHECK( obj_reg.defrauders_out_.empty() );
-        BOOST_TEST( obj_reg.overeager_.empty() );
+        BOOST_CHECK( obj_reg.overeager_.empty() );
-        BOOST_TEST( obj_reg.overkilled_.empty() );
+        BOOST_CHECK( obj_reg.overkilled_.empty() );
        // Getting the addresses of the objects ensure
        // that they're used, and not optimized away.
@ -211,11 +209,11 @@ test_main( int , char * [] )
        cout << "Object 'gc2' is at " << &gc2 << '.' << endl;
    }
-    BOOST_TEST( obj_reg.db_.empty() );
+    BOOST_CHECK( obj_reg.db_.empty() );
-    BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
+    BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
-    BOOST_TEST( obj_reg.defrauders_out_.size() == 1 );
+    BOOST_CHECK( obj_reg.defrauders_out_.size() == 1 );
-    BOOST_TEST( obj_reg.overeager_.empty() );
+    BOOST_CHECK( obj_reg.overeager_.empty() );
-    BOOST_TEST( obj_reg.overkilled_.empty() );
+    BOOST_CHECK( obj_reg.overkilled_.empty() );
    return boost::exit_success;
 }
@ -283,7 +281,7 @@ object_id_compare::operator ()
        }
        else
        {
-            return a.second->before( *b.second );
+            return a.second->before( *b.second ) != 0;
        }
    }
 }
--- a/binary_search_test.cpp
+++ b/binary_search_test.cpp
@ -1,8 +1,7 @@
-// (C) Copyright David Abrahams 2000. Permission to copy, use, modify,
+// (C) Copyright David Abrahams 2000.
-// sell and distribute this software is granted provided this
+// Distributed under the Boost Software License, Version 1.0. (See
-// copyright notice appears in all copies. This software is provided
+// accompanying file LICENSE_1_0.txt or copy at
-// "as is" without express or implied warranty, and with no claim as
+// http://www.boost.org/LICENSE_1_0.txt)
 // to its suitability for any purpose.
 #include <vector>
 #include <string>
@ -14,6 +13,8 @@
 #include <list>
 #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
@ -27,7 +28,16 @@
 namespace {
-typedef std::vector<std::string> string_vector;
+// In order to get ADL to find the comparison operators defined below, they have
 struct mystring : std::string
 {
    typedef std::string base;
    mystring(std::string const& x)
        : base(x) {}
 };
 typedef std::vector<mystring> string_vector;
 const std::size_t sequence_length = 1000;
@ -74,20 +84,21 @@ struct cmp
    }
 };
-inline bool operator<(const std::string& x, const unsigned y)
+inline bool operator<(const mystring& x, const unsigned y)
 {
    return to_int(x) < y;
 }
-inline bool operator<(const unsigned y, const std::string& x)
+inline bool operator<(const unsigned y, const mystring& x)
 {
    return y < to_int(x);
 }
-template <class T> void sort_by_value(T&);
+template <class T>
 void sort_by_value(T& x);
-template <>
+template <class T>
-void sort_by_value(std::vector<std::string>& v)
+void sort_by_value_(T& v, long)
 {
    std::sort(v.begin(), v.end(), cmp());
 }
@ -103,28 +114,26 @@ void random_sorted_sequence(T& seq)
    sort_by_value(seq);
 }
-# if defined(BOOST_MSVC) && BOOST_MSVC < 1300 && !defined(__SGI_STL_PORT)
+template <class T, class A>
 void sort_by_value_(std::list<T,A>& l, int)
 {
 # if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) && !defined(__SGI_STL_PORT)
 // VC6's standard lib doesn't have a template member function for list::sort()
-template <>
+    std::vector<T> seq;
 void random_sorted_sequence(std::list<std::string>& result)
 {
    std::vector<std::string> seq;
    seq.reserve(sequence_length);
-    for (std::size_t i = 0; i < sequence_length; ++i)
+    std::copy(l.begin(), l.end(), std::back_inserter(seq));
    {
        push_back_random_number_string(seq);
    }
    sort_by_value(seq);
-    result.resize(seq.size());
+    std::copy(seq.begin(), seq.end(), l.begin());
-    std::copy(seq.begin(), seq.end(), result.begin());
+# else
 }
 #else
 template <>
 inline void sort_by_value(std::list<std::string>& l)
 {
    l.sort(cmp());
 }
 # endif
 }
 template <class T>
 void sort_by_value(T& x)
 {
    (sort_by_value_)(x, 1);
 }
 // A way to select the comparisons with/without a Compare parameter for testing.
 template <class Compare> struct searches
@ -233,13 +242,13 @@ void test_loop(Sequence& x, Compare cmp, unsigned long test_count)
 int main()
 {
-    std::vector<std::string> x;
+    string_vector x;
    std::cout << "=== testing random-access iterators with <: ===\n";
    test_loop(x, no_compare(), 25);
    std::cout << "=== testing random-access iterators with compare: ===\n";
    test_loop(x, cmp(), 25);
-    std::list<std::string> y;
+    std::list<mystring> y;
    std::cout << "=== testing bidirectional iterators with <: ===\n";
    test_loop(y, no_compare(), 25);
    std::cout << "=== testing bidirectional iterators with compare: ===\n";
--- a/binary_test.cpp
+++ b/binary_test.cpp
@ -0,0 +1,647 @@
 /*=============================================================================
    Copyright (c) 2006, 2007 Matthew Calabrese
    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #include <boost/test/minimal.hpp>
 #include <boost/utility/binary.hpp>
 #include <algorithm>
 #include <cstddef>
 #ifdef BOOST_MSVC
 #pragma warning(disable:4996) // warning C4996: 'std::equal': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators'
 #endif
 /*
 Note: This file tests every single valid bit-grouping on its own, and some
      random combinations of bit-groupings.
 */
 std::size_t const num_random_test_values = 32;
 // Note: These hex values should all correspond with the binary array below
 unsigned int const random_unsigned_ints_hex[num_random_test_values]
  = { 0x0103u, 0x77ebu, 0x5f36u, 0x1f18u, 0xc530u, 0xa73au, 0xd6f8u, 0x0919u
    , 0xfbb0u, 0x3e7cu, 0xd0e9u, 0x22c8u, 0x724eu, 0x14fau, 0xd98eu, 0x40b5
    , 0xeba0u, 0xfe50u, 0x688au, 0x1b05u, 0x5f9cu, 0xe4fcu, 0xa7b8u, 0xd3acu
    , 0x1dddu, 0xbf04u, 0x8352u, 0xe89cu, 0x7506u, 0xe767u, 0xf489u, 0xe167
    };
 unsigned int const random_unsigned_ints_binary[num_random_test_values]
  = { BOOST_BINARY( 0 00010000 0011 ), BOOST_BINARY( 0 11101 1111  101011 )
    , BOOST_BINARY( 010111 1100110 1 1 0 ), BOOST_BINARY( 000 1 11110 00 11000 )
    , BOOST_BINARY( 110 001010 0110 000 ), BOOST_BINARY( 1010 01110011 1010 )
    , BOOST_BINARY( 11 010 1 101111 1000 ), BOOST_BINARY( 0000 100100 0110 01 )
    , BOOST_BINARY( 1111 101110 11 0000 ), BOOST_BINARY( 00111110 01111100 )
    , BOOST_BINARY( 11  010 000111 01001 ), BOOST_BINARY( 00100 010110   01000 )
    , BOOST_BINARY( 01 11001001 001110 ), BOOST_BINARY( 0010 1001111 1010 )
    , BOOST_BINARY( 1101 1 00110 0 01110 ), BOOST_BINARY( 100 000 01011010 1 )
    , BOOST_BINARY( 11 1010 1110 1000 00 ), BOOST_BINARY( 11111 110010 10000 )
    , BOOST_BINARY( 01101 00010 001010 ), BOOST_BINARY( 000 11011 000001 01 )
    , BOOST_BINARY( 01 01111 1100111 00 ), BOOST_BINARY( 1 110010 0111111 00 )
    , BOOST_BINARY( 101 0011 11 01110 00 ), BOOST_BINARY( 110100 1 110101 100 )
    , BOOST_BINARY( 00 1110111 011 101 ), BOOST_BINARY( 1011 1111 00000 100 )
    , BOOST_BINARY( 1000 00110 101 0010 ), BOOST_BINARY( 1110  10001 001110 0 )
    , BOOST_BINARY( 011 1010100 000 110 ), BOOST_BINARY( 1110 0111 01100 111 )
    , BOOST_BINARY( 11110 10010 001001 ), BOOST_BINARY( 11 1000010 1100 111 )
    };
 unsigned int const unsigned_ints_1_bit[2] =
 { BOOST_BINARY( 0 )
 , BOOST_BINARY( 1 )
 };
 unsigned int const unsigned_ints_2_bits[4] =
 { BOOST_BINARY( 00 )
 , BOOST_BINARY( 01 )
 , BOOST_BINARY( 10 )
 , BOOST_BINARY( 11 )
 };
 unsigned int const unsigned_ints_3_bits[8] =
 { BOOST_BINARY( 000 )
 , BOOST_BINARY( 001 )
 , BOOST_BINARY( 010 )
 , BOOST_BINARY( 011 )
 , BOOST_BINARY( 100 )
 , BOOST_BINARY( 101 )
 , BOOST_BINARY( 110 )
 , BOOST_BINARY( 111 )
 };
 unsigned int const unsigned_ints_4_bits[16] =
 { BOOST_BINARY( 0000 )
 , BOOST_BINARY( 0001 )
 , BOOST_BINARY( 0010 )
 , BOOST_BINARY( 0011 )
 , BOOST_BINARY( 0100 )
 , BOOST_BINARY( 0101 )
 , BOOST_BINARY( 0110 )
 , BOOST_BINARY( 0111 )
 , BOOST_BINARY( 1000 )
 , BOOST_BINARY( 1001 )
 , BOOST_BINARY( 1010 )
 , BOOST_BINARY( 1011 )
 , BOOST_BINARY( 1100 )
 , BOOST_BINARY( 1101 )
 , BOOST_BINARY( 1110 )
 , BOOST_BINARY( 1111 )
 };
 unsigned int const unsigned_ints_5_bits[32] =
 { BOOST_BINARY( 00000 )
 , BOOST_BINARY( 00001 )
 , BOOST_BINARY( 00010 )
 , BOOST_BINARY( 00011 )
 , BOOST_BINARY( 00100 )
 , BOOST_BINARY( 00101 )
 , BOOST_BINARY( 00110 )
 , BOOST_BINARY( 00111 )
 , BOOST_BINARY( 01000 )
 , BOOST_BINARY( 01001 )
 , BOOST_BINARY( 01010 )
 , BOOST_BINARY( 01011 )
 , BOOST_BINARY( 01100 )
 , BOOST_BINARY( 01101 )
 , BOOST_BINARY( 01110 )
 , BOOST_BINARY( 01111 )
 , BOOST_BINARY( 10000 )
 , BOOST_BINARY( 10001 )
 , BOOST_BINARY( 10010 )
 , BOOST_BINARY( 10011 )
 , BOOST_BINARY( 10100 )
 , BOOST_BINARY( 10101 )
 , BOOST_BINARY( 10110 )
 , BOOST_BINARY( 10111 )
 , BOOST_BINARY( 11000 )
 , BOOST_BINARY( 11001 )
 , BOOST_BINARY( 11010 )
 , BOOST_BINARY( 11011 )
 , BOOST_BINARY( 11100 )
 , BOOST_BINARY( 11101 )
 , BOOST_BINARY( 11110 )
 , BOOST_BINARY( 11111 )
 };
 unsigned int const unsigned_ints_6_bits[64] =
 { BOOST_BINARY( 000000 )
 , BOOST_BINARY( 000001 )
 , BOOST_BINARY( 000010 )
 , BOOST_BINARY( 000011 )
 , BOOST_BINARY( 000100 )
 , BOOST_BINARY( 000101 )
 , BOOST_BINARY( 000110 )
 , BOOST_BINARY( 000111 )
 , BOOST_BINARY( 001000 )
 , BOOST_BINARY( 001001 )
 , BOOST_BINARY( 001010 )
 , BOOST_BINARY( 001011 )
 , BOOST_BINARY( 001100 )
 , BOOST_BINARY( 001101 )
 , BOOST_BINARY( 001110 )
 , BOOST_BINARY( 001111 )
 , BOOST_BINARY( 010000 )
 , BOOST_BINARY( 010001 )
 , BOOST_BINARY( 010010 )
 , BOOST_BINARY( 010011 )
 , BOOST_BINARY( 010100 )
 , BOOST_BINARY( 010101 )
 , BOOST_BINARY( 010110 )
 , BOOST_BINARY( 010111 )
 , BOOST_BINARY( 011000 )
 , BOOST_BINARY( 011001 )
 , BOOST_BINARY( 011010 )
 , BOOST_BINARY( 011011 )
 , BOOST_BINARY( 011100 )
 , BOOST_BINARY( 011101 )
 , BOOST_BINARY( 011110 )
 , BOOST_BINARY( 011111 )
 , BOOST_BINARY( 100000 )
 , BOOST_BINARY( 100001 )
 , BOOST_BINARY( 100010 )
 , BOOST_BINARY( 100011 )
 , BOOST_BINARY( 100100 )
 , BOOST_BINARY( 100101 )
 , BOOST_BINARY( 100110 )
 , BOOST_BINARY( 100111 )
 , BOOST_BINARY( 101000 )
 , BOOST_BINARY( 101001 )
 , BOOST_BINARY( 101010 )
 , BOOST_BINARY( 101011 )
 , BOOST_BINARY( 101100 )
 , BOOST_BINARY( 101101 )
 , BOOST_BINARY( 101110 )
 , BOOST_BINARY( 101111 )
 , BOOST_BINARY( 110000 )
 , BOOST_BINARY( 110001 )
 , BOOST_BINARY( 110010 )
 , BOOST_BINARY( 110011 )
 , BOOST_BINARY( 110100 )
 , BOOST_BINARY( 110101 )
 , BOOST_BINARY( 110110 )
 , BOOST_BINARY( 110111 )
 , BOOST_BINARY( 111000 )
 , BOOST_BINARY( 111001 )
 , BOOST_BINARY( 111010 )
 , BOOST_BINARY( 111011 )
 , BOOST_BINARY( 111100 )
 , BOOST_BINARY( 111101 )
 , BOOST_BINARY( 111110 )
 , BOOST_BINARY( 111111 )
 };
 unsigned int const unsigned_ints_7_bits[128] =
 { BOOST_BINARY( 0000000 )
 , BOOST_BINARY( 0000001 )
 , BOOST_BINARY( 0000010 )
 , BOOST_BINARY( 0000011 )
 , BOOST_BINARY( 0000100 )
 , BOOST_BINARY( 0000101 )
 , BOOST_BINARY( 0000110 )
 , BOOST_BINARY( 0000111 )
 , BOOST_BINARY( 0001000 )
 , BOOST_BINARY( 0001001 )
 , BOOST_BINARY( 0001010 )
 , BOOST_BINARY( 0001011 )
 , BOOST_BINARY( 0001100 )
 , BOOST_BINARY( 0001101 )
 , BOOST_BINARY( 0001110 )
 , BOOST_BINARY( 0001111 )
 , BOOST_BINARY( 0010000 )
 , BOOST_BINARY( 0010001 )
 , BOOST_BINARY( 0010010 )
 , BOOST_BINARY( 0010011 )
 , BOOST_BINARY( 0010100 )
 , BOOST_BINARY( 0010101 )
 , BOOST_BINARY( 0010110 )
 , BOOST_BINARY( 0010111 )
 , BOOST_BINARY( 0011000 )
 , BOOST_BINARY( 0011001 )
 , BOOST_BINARY( 0011010 )
 , BOOST_BINARY( 0011011 )
 , BOOST_BINARY( 0011100 )
 , BOOST_BINARY( 0011101 )
 , BOOST_BINARY( 0011110 )
 , BOOST_BINARY( 0011111 )
 , BOOST_BINARY( 0100000 )
 , BOOST_BINARY( 0100001 )
 , BOOST_BINARY( 0100010 )
 , BOOST_BINARY( 0100011 )
 , BOOST_BINARY( 0100100 )
 , BOOST_BINARY( 0100101 )
 , BOOST_BINARY( 0100110 )
 , BOOST_BINARY( 0100111 )
 , BOOST_BINARY( 0101000 )
 , BOOST_BINARY( 0101001 )
 , BOOST_BINARY( 0101010 )
 , BOOST_BINARY( 0101011 )
 , BOOST_BINARY( 0101100 )
 , BOOST_BINARY( 0101101 )
 , BOOST_BINARY( 0101110 )
 , BOOST_BINARY( 0101111 )
 , BOOST_BINARY( 0110000 )
 , BOOST_BINARY( 0110001 )
 , BOOST_BINARY( 0110010 )
 , BOOST_BINARY( 0110011 )
 , BOOST_BINARY( 0110100 )
 , BOOST_BINARY( 0110101 )
 , BOOST_BINARY( 0110110 )
 , BOOST_BINARY( 0110111 )
 , BOOST_BINARY( 0111000 )
 , BOOST_BINARY( 0111001 )
 , BOOST_BINARY( 0111010 )
 , BOOST_BINARY( 0111011 )
 , BOOST_BINARY( 0111100 )
 , BOOST_BINARY( 0111101 )
 , BOOST_BINARY( 0111110 )
 , BOOST_BINARY( 0111111 )
 , BOOST_BINARY( 1000000 )
 , BOOST_BINARY( 1000001 )
 , BOOST_BINARY( 1000010 )
 , BOOST_BINARY( 1000011 )
 , BOOST_BINARY( 1000100 )
 , BOOST_BINARY( 1000101 )
 , BOOST_BINARY( 1000110 )
 , BOOST_BINARY( 1000111 )
 , BOOST_BINARY( 1001000 )
 , BOOST_BINARY( 1001001 )
 , BOOST_BINARY( 1001010 )
 , BOOST_BINARY( 1001011 )
 , BOOST_BINARY( 1001100 )
 , BOOST_BINARY( 1001101 )
 , BOOST_BINARY( 1001110 )
 , BOOST_BINARY( 1001111 )
 , BOOST_BINARY( 1010000 )
 , BOOST_BINARY( 1010001 )
 , BOOST_BINARY( 1010010 )
 , BOOST_BINARY( 1010011 )
 , BOOST_BINARY( 1010100 )
 , BOOST_BINARY( 1010101 )
 , BOOST_BINARY( 1010110 )
 , BOOST_BINARY( 1010111 )
 , BOOST_BINARY( 1011000 )
 , BOOST_BINARY( 1011001 )
 , BOOST_BINARY( 1011010 )
 , BOOST_BINARY( 1011011 )
 , BOOST_BINARY( 1011100 )
 , BOOST_BINARY( 1011101 )
 , BOOST_BINARY( 1011110 )
 , BOOST_BINARY( 1011111 )
 , BOOST_BINARY( 1100000 )
 , BOOST_BINARY( 1100001 )
 , BOOST_BINARY( 1100010 )
 , BOOST_BINARY( 1100011 )
 , BOOST_BINARY( 1100100 )
 , BOOST_BINARY( 1100101 )
 , BOOST_BINARY( 1100110 )
 , BOOST_BINARY( 1100111 )
 , BOOST_BINARY( 1101000 )
 , BOOST_BINARY( 1101001 )
 , BOOST_BINARY( 1101010 )
 , BOOST_BINARY( 1101011 )
 , BOOST_BINARY( 1101100 )
 , BOOST_BINARY( 1101101 )
 , BOOST_BINARY( 1101110 )
 , BOOST_BINARY( 1101111 )
 , BOOST_BINARY( 1110000 )
 , BOOST_BINARY( 1110001 )
 , BOOST_BINARY( 1110010 )
 , BOOST_BINARY( 1110011 )
 , BOOST_BINARY( 1110100 )
 , BOOST_BINARY( 1110101 )
 , BOOST_BINARY( 1110110 )
 , BOOST_BINARY( 1110111 )
 , BOOST_BINARY( 1111000 )
 , BOOST_BINARY( 1111001 )
 , BOOST_BINARY( 1111010 )
 , BOOST_BINARY( 1111011 )
 , BOOST_BINARY( 1111100 )
 , BOOST_BINARY( 1111101 )
 , BOOST_BINARY( 1111110 )
 , BOOST_BINARY( 1111111 )
 };
 unsigned int const unsigned_ints_8_bits[256] =
 { BOOST_BINARY( 00000000 )
 , BOOST_BINARY( 00000001 )
 , BOOST_BINARY( 00000010 )
 , BOOST_BINARY( 00000011 )
 , BOOST_BINARY( 00000100 )
 , BOOST_BINARY( 00000101 )
 , BOOST_BINARY( 00000110 )
 , BOOST_BINARY( 00000111 )
 , BOOST_BINARY( 00001000 )
 , BOOST_BINARY( 00001001 )
 , BOOST_BINARY( 00001010 )
 , BOOST_BINARY( 00001011 )
 , BOOST_BINARY( 00001100 )
 , BOOST_BINARY( 00001101 )
 , BOOST_BINARY( 00001110 )
 , BOOST_BINARY( 00001111 )
 , BOOST_BINARY( 00010000 )
 , BOOST_BINARY( 00010001 )
 , BOOST_BINARY( 00010010 )
 , BOOST_BINARY( 00010011 )
 , BOOST_BINARY( 00010100 )
 , BOOST_BINARY( 00010101 )
 , BOOST_BINARY( 00010110 )
 , BOOST_BINARY( 00010111 )
 , BOOST_BINARY( 00011000 )
 , BOOST_BINARY( 00011001 )
 , BOOST_BINARY( 00011010 )
 , BOOST_BINARY( 00011011 )
 , BOOST_BINARY( 00011100 )
 , BOOST_BINARY( 00011101 )
 , BOOST_BINARY( 00011110 )
 , BOOST_BINARY( 00011111 )
 , BOOST_BINARY( 00100000 )
 , BOOST_BINARY( 00100001 )
 , BOOST_BINARY( 00100010 )
 , BOOST_BINARY( 00100011 )
 , BOOST_BINARY( 00100100 )
 , BOOST_BINARY( 00100101 )
 , BOOST_BINARY( 00100110 )
 , BOOST_BINARY( 00100111 )
 , BOOST_BINARY( 00101000 )
 , BOOST_BINARY( 00101001 )
 , BOOST_BINARY( 00101010 )
 , BOOST_BINARY( 00101011 )
 , BOOST_BINARY( 00101100 )
 , BOOST_BINARY( 00101101 )
 , BOOST_BINARY( 00101110 )
 , BOOST_BINARY( 00101111 )
 , BOOST_BINARY( 00110000 )
 , BOOST_BINARY( 00110001 )
 , BOOST_BINARY( 00110010 )
 , BOOST_BINARY( 00110011 )
 , BOOST_BINARY( 00110100 )
 , BOOST_BINARY( 00110101 )
 , BOOST_BINARY( 00110110 )
 , BOOST_BINARY( 00110111 )
 , BOOST_BINARY( 00111000 )
 , BOOST_BINARY( 00111001 )
 , BOOST_BINARY( 00111010 )
 , BOOST_BINARY( 00111011 )
 , BOOST_BINARY( 00111100 )
 , BOOST_BINARY( 00111101 )
 , BOOST_BINARY( 00111110 )
 , BOOST_BINARY( 00111111 )
 , BOOST_BINARY( 01000000 )
 , BOOST_BINARY( 01000001 )
 , BOOST_BINARY( 01000010 )
 , BOOST_BINARY( 01000011 )
 , BOOST_BINARY( 01000100 )
 , BOOST_BINARY( 01000101 )
 , BOOST_BINARY( 01000110 )
 , BOOST_BINARY( 01000111 )
 , BOOST_BINARY( 01001000 )
 , BOOST_BINARY( 01001001 )
 , BOOST_BINARY( 01001010 )
 , BOOST_BINARY( 01001011 )
 , BOOST_BINARY( 01001100 )
 , BOOST_BINARY( 01001101 )
 , BOOST_BINARY( 01001110 )
 , BOOST_BINARY( 01001111 )
 , BOOST_BINARY( 01010000 )
 , BOOST_BINARY( 01010001 )
 , BOOST_BINARY( 01010010 )
 , BOOST_BINARY( 01010011 )
 , BOOST_BINARY( 01010100 )
 , BOOST_BINARY( 01010101 )
 , BOOST_BINARY( 01010110 )
 , BOOST_BINARY( 01010111 )
 , BOOST_BINARY( 01011000 )
 , BOOST_BINARY( 01011001 )
 , BOOST_BINARY( 01011010 )
 , BOOST_BINARY( 01011011 )
 , BOOST_BINARY( 01011100 )
 , BOOST_BINARY( 01011101 )
 , BOOST_BINARY( 01011110 )
 , BOOST_BINARY( 01011111 )
 , BOOST_BINARY( 01100000 )
 , BOOST_BINARY( 01100001 )
 , BOOST_BINARY( 01100010 )
 , BOOST_BINARY( 01100011 )
 , BOOST_BINARY( 01100100 )
 , BOOST_BINARY( 01100101 )
 , BOOST_BINARY( 01100110 )
 , BOOST_BINARY( 01100111 )
 , BOOST_BINARY( 01101000 )
 , BOOST_BINARY( 01101001 )
 , BOOST_BINARY( 01101010 )
 , BOOST_BINARY( 01101011 )
 , BOOST_BINARY( 01101100 )
 , BOOST_BINARY( 01101101 )
 , BOOST_BINARY( 01101110 )
 , BOOST_BINARY( 01101111 )
 , BOOST_BINARY( 01110000 )
 , BOOST_BINARY( 01110001 )
 , BOOST_BINARY( 01110010 )
 , BOOST_BINARY( 01110011 )
 , BOOST_BINARY( 01110100 )
 , BOOST_BINARY( 01110101 )
 , BOOST_BINARY( 01110110 )
 , BOOST_BINARY( 01110111 )
 , BOOST_BINARY( 01111000 )
 , BOOST_BINARY( 01111001 )
 , BOOST_BINARY( 01111010 )
 , BOOST_BINARY( 01111011 )
 , BOOST_BINARY( 01111100 )
 , BOOST_BINARY( 01111101 )
 , BOOST_BINARY( 01111110 )
 , BOOST_BINARY( 01111111 )
 , BOOST_BINARY( 10000000 )
 , BOOST_BINARY( 10000001 )
 , BOOST_BINARY( 10000010 )
 , BOOST_BINARY( 10000011 )
 , BOOST_BINARY( 10000100 )
 , BOOST_BINARY( 10000101 )
 , BOOST_BINARY( 10000110 )
 , BOOST_BINARY( 10000111 )
 , BOOST_BINARY( 10001000 )
 , BOOST_BINARY( 10001001 )
 , BOOST_BINARY( 10001010 )
 , BOOST_BINARY( 10001011 )
 , BOOST_BINARY( 10001100 )
 , BOOST_BINARY( 10001101 )
 , BOOST_BINARY( 10001110 )
 , BOOST_BINARY( 10001111 )
 , BOOST_BINARY( 10010000 )
 , BOOST_BINARY( 10010001 )
 , BOOST_BINARY( 10010010 )
 , BOOST_BINARY( 10010011 )
 , BOOST_BINARY( 10010100 )
 , BOOST_BINARY( 10010101 )
 , BOOST_BINARY( 10010110 )
 , BOOST_BINARY( 10010111 )
 , BOOST_BINARY( 10011000 )
 , BOOST_BINARY( 10011001 )
 , BOOST_BINARY( 10011010 )
 , BOOST_BINARY( 10011011 )
 , BOOST_BINARY( 10011100 )
 , BOOST_BINARY( 10011101 )
 , BOOST_BINARY( 10011110 )
 , BOOST_BINARY( 10011111 )
 , BOOST_BINARY( 10100000 )
 , BOOST_BINARY( 10100001 )
 , BOOST_BINARY( 10100010 )
 , BOOST_BINARY( 10100011 )
 , BOOST_BINARY( 10100100 )
 , BOOST_BINARY( 10100101 )
 , BOOST_BINARY( 10100110 )
 , BOOST_BINARY( 10100111 )
 , BOOST_BINARY( 10101000 )
 , BOOST_BINARY( 10101001 )
 , BOOST_BINARY( 10101010 )
 , BOOST_BINARY( 10101011 )
 , BOOST_BINARY( 10101100 )
 , BOOST_BINARY( 10101101 )
 , BOOST_BINARY( 10101110 )
 , BOOST_BINARY( 10101111 )
 , BOOST_BINARY( 10110000 )
 , BOOST_BINARY( 10110001 )
 , BOOST_BINARY( 10110010 )
 , BOOST_BINARY( 10110011 )
 , BOOST_BINARY( 10110100 )
 , BOOST_BINARY( 10110101 )
 , BOOST_BINARY( 10110110 )
 , BOOST_BINARY( 10110111 )
 , BOOST_BINARY( 10111000 )
 , BOOST_BINARY( 10111001 )
 , BOOST_BINARY( 10111010 )
 , BOOST_BINARY( 10111011 )
 , BOOST_BINARY( 10111100 )
 , BOOST_BINARY( 10111101 )
 , BOOST_BINARY( 10111110 )
 , BOOST_BINARY( 10111111 )
 , BOOST_BINARY( 11000000 )
 , BOOST_BINARY( 11000001 )
 , BOOST_BINARY( 11000010 )
 , BOOST_BINARY( 11000011 )
 , BOOST_BINARY( 11000100 )
 , BOOST_BINARY( 11000101 )
 , BOOST_BINARY( 11000110 )
 , BOOST_BINARY( 11000111 )
 , BOOST_BINARY( 11001000 )
 , BOOST_BINARY( 11001001 )
 , BOOST_BINARY( 11001010 )
 , BOOST_BINARY( 11001011 )
 , BOOST_BINARY( 11001100 )
 , BOOST_BINARY( 11001101 )
 , BOOST_BINARY( 11001110 )
 , BOOST_BINARY( 11001111 )
 , BOOST_BINARY( 11010000 )
 , BOOST_BINARY( 11010001 )
 , BOOST_BINARY( 11010010 )
 , BOOST_BINARY( 11010011 )
 , BOOST_BINARY( 11010100 )
 , BOOST_BINARY( 11010101 )
 , BOOST_BINARY( 11010110 )
 , BOOST_BINARY( 11010111 )
 , BOOST_BINARY( 11011000 )
 , BOOST_BINARY( 11011001 )
 , BOOST_BINARY( 11011010 )
 , BOOST_BINARY( 11011011 )
 , BOOST_BINARY( 11011100 )
 , BOOST_BINARY( 11011101 )
 , BOOST_BINARY( 11011110 )
 , BOOST_BINARY( 11011111 )
 , BOOST_BINARY( 11100000 )
 , BOOST_BINARY( 11100001 )
 , BOOST_BINARY( 11100010 )
 , BOOST_BINARY( 11100011 )
 , BOOST_BINARY( 11100100 )
 , BOOST_BINARY( 11100101 )
 , BOOST_BINARY( 11100110 )
 , BOOST_BINARY( 11100111 )
 , BOOST_BINARY( 11101000 )
 , BOOST_BINARY( 11101001 )
 , BOOST_BINARY( 11101010 )
 , BOOST_BINARY( 11101011 )
 , BOOST_BINARY( 11101100 )
 , BOOST_BINARY( 11101101 )
 , BOOST_BINARY( 11101110 )
 , BOOST_BINARY( 11101111 )
 , BOOST_BINARY( 11110000 )
 , BOOST_BINARY( 11110001 )
 , BOOST_BINARY( 11110010 )
 , BOOST_BINARY( 11110011 )
 , BOOST_BINARY( 11110100 )
 , BOOST_BINARY( 11110101 )
 , BOOST_BINARY( 11110110 )
 , BOOST_BINARY( 11110111 )
 , BOOST_BINARY( 11111000 )
 , BOOST_BINARY( 11111001 )
 , BOOST_BINARY( 11111010 )
 , BOOST_BINARY( 11111011 )
 , BOOST_BINARY( 11111100 )
 , BOOST_BINARY( 11111101 )
 , BOOST_BINARY( 11111110 )
 , BOOST_BINARY( 11111111 )
 };
 struct left_is_not_one_less_than_right
 {
  bool operator ()( unsigned int left, unsigned int right ) const
  {
    return right != left + 1;
  }
 };
 template< std::size_t Size >
 bool is_ascending_from_0_array( unsigned int const (&array)[Size] )
 {
  unsigned int const* const curr = array,
                    * const end  = array + Size;
  return    ( *curr == 0 )
         && (    std::adjacent_find( curr, end
                                   , left_is_not_one_less_than_right()
                                   )
              == end
            );
 }
 std::size_t const unsigned_int_id = 1,
                  unsigned_long_int_id = 2;
 typedef char (&unsigned_int_id_type)[unsigned_int_id];
 typedef char (&unsigned_long_int_id_type)[unsigned_long_int_id];
 // Note: Functions only used for type checking
 unsigned_int_id_type      binary_type_checker( unsigned int );
 unsigned_long_int_id_type binary_type_checker( unsigned long int );
 int test_main( int, char *[] )
 {
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_1_bit ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_2_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_3_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_4_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_5_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_6_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_7_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_8_bits ) );
  BOOST_CHECK( std::equal( &random_unsigned_ints_hex[0]
                         , random_unsigned_ints_hex + num_random_test_values
                         , &random_unsigned_ints_binary[0]
                         )
             );
  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_U( 110100 1010 ) ) )
               == unsigned_int_id
             );
  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_UL( 11110 ) ) )
               == unsigned_long_int_id
             );
  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_LU( 10 0001 ) ) )
               == unsigned_long_int_id
             );
  return 0;
 }
--- a/call_traits.htm
+++ b/call_traits.htm
@ -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,
+   <p>
-sell and distribute this document is granted provided this
+      Copyright 2000 Steve Cleary, Beman Dawes, Howard
-copyright notice appears in all copies. This document is provided
+      Hinnant and John Maddock. <br/>
-&quot;as is&quot; without express or implied warranty, and with
+      Use, modification and distribution are subject to the
-no claim as to its suitability for any purpose.</p>
+      Boost Software License, Version 1.0.
-
+      (See accompanying file LICENSE_1_0.txt
-<p>Based on contributions by Steve Cleary, Beman Dawes, Howard
+      or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
-Hinnant and John Maddock.</p>
+         http://www.boost.org/LICENSE_1_0.txt
-
+      </a>).
-<p>Maintained by <a href="mailto:John_Maddock@compuserve.com">John
+   </p>
 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>
 </body>
 </html>
--- a/call_traits_test.cpp
+++ b/call_traits_test.cpp
@ -1,9 +1,10 @@
- // boost::compressed_pair test program   
+//  boost::compressed_pair test program   
- //  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
+//  (C) Copyright John Maddock 2000. 
- //  distribute this software is granted provided this copyright notice appears   
+//  Use, modification and distribution are subject to the Boost Software License,
- //  in all copies. This software is provided "as is" without express or implied   
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- //  warranty, and with no claim as to its suitability for any purpose.   
+//  http://www.boost.org/LICENSE_1_0.txt).
 // standalone test program for <boost/call_traits.hpp>
 // 18 Mar 2002:
@ -11,14 +12,18 @@
 // 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>
 #ifdef BOOST_MSVC
 #pragma warning(disable:4181) // : warning C4181: qualifier applied to reference type; ignored
 #endif
 // a way prevent warnings for unused variables
 template<class T> inline void unused_variable(const T&) {}
@ -51,7 +56,8 @@ struct contained
   const_reference const_get()const { return v_; }
   // pass value:
   void call(param_type){}
-
+private:
   contained& operator=(const contained&);
 };
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@ -76,6 +82,8 @@ struct contained<T[N]>
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
   void call(param_type){}
 private:
   contained& operator=(const contained&);
 };
 #endif
@ -120,9 +128,9 @@ void call_traits_checker<T>::operator()(param_type p)
   T t(p);
   contained<T> c(t);
   cout << "checking contained<" << typeid(T).name() << ">..." << endl;
-   assert(t == c.value());
+   BOOST_CHECK(t == c.value());
-   assert(t == c.get());
+   BOOST_CHECK(t == c.get());
-   assert(t == c.const_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;
@ -144,11 +152,11 @@ struct call_traits_checker<T[N]>
      cout << "checking contained<" << typeid(T[N]).name() << ">..." << endl;
      unsigned int i = 0;
      for(i = 0; i < N; ++i)
-         assert(t[i] == c.value()[i]);
+         BOOST_CHECK(t[i] == c.value()[i]);
      for(i = 0; i < N; ++i)
-         assert(t[i] == c.get()[i]);
+         BOOST_CHECK(t[i] == c.get()[i]);
      for(i = 0; i < N; ++i)
-         assert(t[i] == c.const_get()[i]);
+         BOOST_CHECK(t[i] == c.const_get()[i]);
      cout << "typeof contained<" << typeid(T[N]).name() << ">::v_ is:         " << typeid(&contained<T[N]>::v_).name() << endl;
      cout << "typeof contained<" << typeid(T[N]).name() << ">::value is:      " << typeid(&contained<T[N]>::value).name() << endl;
@ -166,7 +174,7 @@ template <class W, class U>
 void check_wrap(const W& w, const U& u)
 {
   cout << "checking " << typeid(W).name() << "..." << endl;
-   assert(w.value() == u);
+   BOOST_CHECK(w.value() == u);
 }
 //
@ -177,8 +185,8 @@ template <class T, class U, class V>
 void check_make_pair(T c, U u, V v)
 {
   cout << "checking std::pair<" << typeid(c.first).name() << ", " << typeid(c.second).name() << ">..." << endl;
-   assert(c.first == u);
+   BOOST_CHECK(c.first == u);
-   assert(c.second == v);
+   BOOST_CHECK(c.second == v);
   cout << endl;
 }
@ -196,7 +204,7 @@ struct comparible_UDT
   bool operator == (const comparible_UDT& v){ return v.i_ == i_; }
 };
-int main(int argc, char *argv[ ])
+int main()
 {
   call_traits_checker<comparible_UDT> c1;
   comparible_UDT u;
@ -230,73 +238,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)
+   BOOST_CHECK_TYPE(comparible_UDT, boost::call_traits<comparible_UDT>::value_type);
-   type_test(comparible_UDT&, boost::call_traits<comparible_UDT>::reference)
+   BOOST_CHECK_TYPE(comparible_UDT&, boost::call_traits<comparible_UDT>::reference);
-   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference)
+   BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference);
-   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type)
+   BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type);
-   type_test(int, boost::call_traits<int>::value_type)
+   BOOST_CHECK_TYPE(int, boost::call_traits<int>::value_type);
-   type_test(int&, boost::call_traits<int>::reference)
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int>::reference);
-   type_test(const int&, boost::call_traits<int>::const_reference)
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<int>::const_reference);
-   type_test(const int, boost::call_traits<int>::param_type)
+   BOOST_CHECK_TYPE(const int, boost::call_traits<int>::param_type);
-   type_test(int*, boost::call_traits<int*>::value_type)
+   BOOST_CHECK_TYPE(int*, boost::call_traits<int*>::value_type);
-   type_test(int*&, boost::call_traits<int*>::reference)
+   BOOST_CHECK_TYPE(int*&, boost::call_traits<int*>::reference);
-   type_test(int*const&, boost::call_traits<int*>::const_reference)
+   BOOST_CHECK_TYPE(int*const&, boost::call_traits<int*>::const_reference);
-   type_test(int*const, boost::call_traits<int*>::param_type)
+   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)
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::value_type);
-   type_test(int&, boost::call_traits<int&>::reference)
+   BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::reference);
-   type_test(const int&, boost::call_traits<int&>::const_reference)
+   BOOST_CHECK_TYPE(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&>::param_type);
 #if !(defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC__ == 3) && (__GNUC_MINOR__ < 1)))
-   type_test(int&, boost::call_traits<cr_type>::value_type)
+   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::value_type);
-   type_test(int&, boost::call_traits<cr_type>::reference)
+   BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::reference);
-   type_test(const int&, boost::call_traits<cr_type>::const_reference)
+   BOOST_CHECK_TYPE(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>::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)
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::value_type);
-   type_test(const int&, boost::call_traits<const int&>::reference)
+   BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::reference);
-   type_test(const int&, boost::call_traits<const int&>::const_reference)
+   BOOST_CHECK_TYPE(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&>::param_type);
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   type_test(const int*, boost::call_traits<int[3]>::value_type)
+   BOOST_CHECK_TYPE(const int*, boost::call_traits<int[3]>::value_type);
-   type_test(int(&)[3], boost::call_traits<int[3]>::reference)
+   BOOST_CHECK_TYPE(int(&)[3], boost::call_traits<int[3]>::reference);
-   type_test(const int(&)[3], boost::call_traits<int[3]>::const_reference)
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<int[3]>::const_reference);
-   type_test(const int*const, boost::call_traits<int[3]>::param_type)
+   BOOST_CHECK_TYPE(const int*const, boost::call_traits<int[3]>::param_type);
-   type_test(const int*, boost::call_traits<const int[3]>::value_type)
+   BOOST_CHECK_TYPE(const int*, boost::call_traits<const int[3]>::value_type);
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::reference)
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::reference);
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::const_reference)
+   BOOST_CHECK_TYPE(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*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)
+   BOOST_CHECK_TYPE(test_abc1, boost::call_traits<test_abc1>::value_type);
-   type_test(test_abc1&, boost::call_traits<test_abc1>::reference)
+   BOOST_CHECK_TYPE(test_abc1&, boost::call_traits<test_abc1>::reference);
-   type_test(const test_abc1&, boost::call_traits<test_abc1>::const_reference)
+   BOOST_CHECK_TYPE(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(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)
+   BOOST_CHECK_TYPE(incomplete_type, boost::call_traits<incomplete_type>::value_type);
-   type_test(incomplete_type&, boost::call_traits<incomplete_type>::reference)
+   BOOST_CHECK_TYPE(incomplete_type&, boost::call_traits<incomplete_type>::reference);
-   type_test(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference)
+   BOOST_CHECK_TYPE(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(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
@ -408,23 +410,3 @@ template struct call_traits_test<int[2], true>;
 #endif
 #endif
 #ifdef BOOST_MSVC
 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
@ -0,0 +1,122 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <html>
 	<head>
 		<title>Boost: checked_delete.hpp documentation</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
 		<table border="0" width="100%">
 			<tr>
 				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
 				</td>
 				<td align="center">
 					<h1>checked_delete.hpp</h1>
 				</td>
 			</tr>
 			<tr>
 				<td colspan="2" height="64">&nbsp;</td>
 			</tr>
 		</table>
 		<p>
 			The header <STRONG>&lt;boost/checked_delete.hpp&gt;</STRONG> defines two 
 			function templates, <STRONG>checked_delete</STRONG> and <STRONG>checked_array_delete</STRONG>, 
 			and two class templates, <STRONG>checked_deleter</STRONG> and <STRONG>checked_array_deleter</STRONG>.
 		</p>
 		<P>The C++ Standard allows, in 5.3.5/5, pointers to incomplete class types to be 
 			deleted with a <EM>delete-expression</EM>. When the class has a non-trivial 
 			destructor, or a class-specific operator delete, the behavior is undefined. 
 			Some compilers issue a warning when an incomplete type is deleted, but 
 			unfortunately, not all do, and programmers sometimes ignore or disable 
 			warnings.</P>
 		<P>A particularly troublesome case is when a smart pointer's destructor, such as <STRONG>
 				boost::scoped_ptr&lt;T&gt;::~scoped_ptr</STRONG>, is instantiated with an 
 			incomplete type. This can often lead to silent, hard to track failures.</P>
 		<P>The supplied function and class templates can be used to prevent these problems, 
 			as they require a complete type, and cause a compilation error otherwise.</P>
 		<h3><a name="Synopsis">Synopsis</a></h3>
 		<pre>
 namespace boost
 {
 template&lt;class T&gt; void checked_delete(T * p);
 template&lt;class T&gt; void checked_array_delete(T * p);
 template&lt;class T&gt; struct checked_deleter;
 template&lt;class T&gt; struct checked_array_deleter;
 }
 </pre>
 		<h3>checked_delete</h3>
 		<h4><a name="checked_delete">template&lt;class T&gt; void checked_delete(T * p);</a></h4>
 		<blockquote>
 			<p>
 				<b>Requires:</b> <b>T</b> must be a complete type. The expression <tt>delete p</tt>
 				must be well-formed.
 			</p>
 			<p>
 				<b>Effects:</b> <tt>delete p;</tt>
 			</p>
 		</blockquote>
 		<h3>checked_array_delete</h3>
 		<h4><a name="checked_array_delete">template&lt;class T&gt; void checked_array_delete(T 
 				* p);</a></h4>
 		<blockquote>
 			<p>
 				<b>Requires:</b> <b>T</b> must be a complete type. The expression <tt>delete [] p</tt>
 				must be well-formed.
 			</p>
 			<p>
 				<b>Effects:</b> <tt>delete [] p;</tt>
 			</p>
 		</blockquote>
 		<h3>checked_deleter</h3>
 		<pre>
 template&lt;class T&gt; struct checked_deleter
 {
    typedef void result_type;
    typedef T * argument_type;
    void operator()(T * p) const;
 };
 </pre>
 		<h4>void checked_deleter&lt;T&gt;::operator()(T * p) const;</h4>
 		<blockquote>
 			<p>
 				<b>Requires:</b> <b>T</b> must be a complete type. The expression <tt>delete p</tt>
 				must be well-formed.
 			</p>
 			<p>
 				<b>Effects:</b> <tt>delete p;</tt>
 			</p>
 		</blockquote>
 		<h3>checked_array_deleter</h3>
 		<pre>
 template&lt;class T&gt; struct checked_array_deleter
 {
    typedef void result_type;
    typedef T * argument_type;
    void operator()(T * p) const;
 };
 </pre>
 		<h4>void checked_array_deleter&lt;T&gt;::operator()(T * p) const;</h4>
 		<blockquote>
 			<p>
 				<b>Requires:</b> <b>T</b> must be a complete type. The expression <tt>delete [] p</tt>
 				must be well-formed.
 			</p>
 			<p>
 				<b>Effects:</b> <tt>delete [] p;</tt>
 			</p>
 		</blockquote>
 		<h3><a name="Acknowledgements">Acknowledgements</a></h3>
 		<p>
 			The function templates <STRONG>checked_delete</STRONG> and <STRONG>checked_array_delete</STRONG>
 			were originally part of <STRONG>&lt;boost/utility.hpp&gt;</STRONG>, and the 
 			documentation acknowledged Beman Dawes, Dave Abrahams, Vladimir Prus, Rainer 
 			Deyke, John Maddock, and others as contributors.
 		</p>
 		<p>
 			<br>
 			<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,17 +1,15 @@
 //  Boost checked_delete test program  ---------------------------------------//
-//  (C) Copyright Beman Dawes 2001. Permission to copy, use, modify, sell
+//  Copyright Beman Dawes 2001.  Distributed under the Boost
-//  and distribute this software is granted provided this copyright
+//  Software License, Version 1.0. (See accompanying file
-//  notice appears in all copies. This software is provided "as is" without
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //  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.
+//  See http://www.boost.org/libs/utility for documentation.
 //  Revision History
 //  21 May 01  Initial version (Beman Dawes)
-#include <boost/utility.hpp>  // for checked_delete
+#include <boost/checked_delete.hpp>  // for checked_delete
 //  This program demonstrates compiler errors when trying to delete an
 //  incomplete type.
@ -23,9 +21,8 @@ namespace
 int main()
 {
-    Incomplete * p;
+    Incomplete * p = 0;
    boost::checked_delete(p);          // should cause compile time error
-    Incomplete ** pa;
+    boost::checked_array_delete(p);    // should cause compile time error
    boost::checked_array_delete(pa);   // should cause compile time error
    return 0;
 }   // main
--- a/compressed_pair.htm
+++ b/compressed_pair.htm
@ -1,30 +1,19 @@
 <html>
-
+   <head>
-<head>
+      <title>Header </title>
-<meta http-equiv="Content-Type"
+      <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-content="text/html; charset=iso-8859-1">
+      <meta name="Template" content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="Template"
+      <meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
+      <boostcompressed_pair.hpp>
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
+   </head>
-<title>Header </title>
+   <body bgcolor="#ffffff" text="#000000" link="#0000ff" vlink="#800080">
-<boost/compressed_pair.hpp>
+      <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>
-</head>
+      <p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are defined inside 
-
+         namespace boost.</p>
-<body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
+      <p>The class compressed pair is very similar to std::pair, but if either of the 
-vlink="#800080">
+         template arguments are empty classes, then the "empty base-class optimisation" 
-
+         is applied to compress the size of the pair.</p>
-<h2><img src="../../c++boost.gif" width="276" height="86">Header
+      <pre>template &lt;class T1, class T2&gt;
 &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;
 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
+   </body>
-functions first() and second(). Note that not all member
+</html>
 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_Maddock@compuserve.com">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>
--- a/compressed_pair_test.cpp
+++ b/compressed_pair_test.cpp
@ -1,9 +1,9 @@
- // boost::compressed_pair test program   
+//  boost::compressed_pair test program   
- //  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
+//  (C) Copyright John Maddock 2000. 
- //  distribute this software is granted provided this copyright notice appears   
+//  Use, modification and distribution are subject to the Boost Software License,
- //  in all copies. This software is provided "as is" without express or implied   
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- //  warranty, and with no claim as to its suitability for any purpose.   
+//  http://www.boost.org/LICENSE_1_0.txt).
 // standalone test program for <boost/compressed_pair.hpp>
 // Revised 03 Oct 2000: 
@ -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 {
+struct empty_UDT
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+{
-template <> struct is_empty<empty_UDT>
+   ~empty_UDT(){};
-{ static const bool value = true; };
+   empty_UDT& operator=(const empty_UDT&){ return *this; }
-template <> struct is_empty<empty_POD_UDT>
+   bool operator==(const empty_UDT&)const
-{ static const bool value = true; };
+   { return true; }
-template <> struct is_POD<empty_POD_UDT>
+};
-{ static const bool value = true; };
+struct empty_POD_UDT
-#else
+{
-template <> struct is_empty<empty_UDT>
+   empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; }
-{ enum{ value = true }; };
+   bool operator==(const empty_POD_UDT&)const
-template <> struct is_empty<empty_POD_UDT>
+   { return true; }
-{ enum{ value = true }; };
+};
 template <> struct is_POD<empty_POD_UDT>
 { enum{ value = true }; };
 #endif
 }
 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_CHECK(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
+   BOOST_CHECK(cp2.second() == p2);
   // second param construct:
   boost::compressed_pair<T1,T2> cp3(p2);
   cp3.first() = p1;
-   BOOST_TEST(cp3.second() == p2);
+   BOOST_CHECK(cp3.second() == p2);
-   BOOST_TEST(cp3.first() == p1);
+   BOOST_CHECK(cp3.first() == p1);
   // both param construct:
   boost::compressed_pair<T1,T2> cp4(p1, p2);
-   BOOST_TEST(cp4.first() == p1);
+   BOOST_CHECK(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
+   BOOST_CHECK(cp4.second() == p2);
   boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
+   BOOST_CHECK(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp5.second() == p4);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.second() == p2);
   // copy construct:
   boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
+   BOOST_CHECK(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
+   BOOST_CHECK(cp6.second() == p2);
   // assignment:
   cp1 = cp4;
-   BOOST_TEST(cp1.first() == p1);
+   BOOST_CHECK(cp1.first() == p1);
-   BOOST_TEST(cp1.second() == p2);
+   BOOST_CHECK(cp1.second() == p2);
   cp1 = cp5;
-   BOOST_TEST(cp1.first() == p3);
+   BOOST_CHECK(cp1.first() == p3);
-   BOOST_TEST(cp1.second() == p4);
+   BOOST_CHECK(cp1.second() == p4);
   // swap:
   cp4.swap(cp5);
-   BOOST_TEST(cp4.first() == p3);
+   BOOST_CHECK(cp4.first() == p3);
-   BOOST_TEST(cp4.second() == p4);
+   BOOST_CHECK(cp4.second() == p4);
-   BOOST_TEST(cp5.first() == p1);
+   BOOST_CHECK(cp5.first() == p1);
-   BOOST_TEST(cp5.second() == p2);
+   BOOST_CHECK(cp5.second() == p2);
   swap(cp4,cp5);
-   BOOST_TEST(cp4.first() == p1);
+   BOOST_CHECK(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
+   BOOST_CHECK(cp4.second() == p2);
-   BOOST_TEST(cp5.first() == p3);
+   BOOST_CHECK(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   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_CHECK(cp4.first() == p1);
-   BOOST_TEST(cp4.second() == p2);
+   BOOST_CHECK(cp4.second() == p2);
   boost::compressed_pair<T1,T2> cp5(p3, p4);
-   BOOST_TEST(cp5.first() == p3);
+   BOOST_CHECK(cp5.first() == p3);
-   BOOST_TEST(cp5.second() == p4);
+   BOOST_CHECK(cp5.second() == p4);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
-   BOOST_TEST(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second() == p2);
+   BOOST_CHECK(cpr1.second() == p2);
   // copy construct:
   boost::compressed_pair<T1,T2> cp6(cp4);
-   BOOST_TEST(cp6.first() == p1);
+   BOOST_CHECK(cp6.first() == p1);
-   BOOST_TEST(cp6.second() == p2);
+   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_CHECK(cp4.first() == p3);
-   BOOST_TEST(cp4.second() == p4);
+   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_CHECK(cp2.first() == p1);
-   BOOST_TEST(cp2.second() == p2);
+   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_CHECK(cp3.second() == p2);
-   BOOST_TEST(cp3.first() == p1);
+   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_CHECK(cp3.second() == p2);
-   BOOST_TEST(cp3.first()[0] == p1[0]);
+   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_CHECK(cpr1.first()[0] == p1[0]);
-   BOOST_TEST(cpr1.second() == p2);
+   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_CHECK(cp2.first() == p1);
-   BOOST_TEST(cp2.second()[0] == p2[0]);
+   BOOST_CHECK(cp2.second()[0] == p2[0]);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp2;
-   BOOST_TEST(cpr1.first() == p1);
+   BOOST_CHECK(cpr1.first() == p1);
-   BOOST_TEST(cpr1.second()[0] == p2[0]);
+   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_CHECK(cp1.first()[0] == p1[0]);
-   BOOST_TEST(cp1.second()[0] == p2[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_CHECK(cpr1.first()[0] == p1[0]);
-   BOOST_TEST(cpr1.second()[0] == p2[0]);
+   BOOST_CHECK(cpr1.second()[0] == p2[0]);
-   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
+   BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
-   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
+   BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
 }
 int test_main(int, char *[])
--- a/counting_iterator.htm
+++ b/counting_iterator.htm
@ -1,325 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Counting 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">
 <h1>Counting Iterator Adaptor</h1>
 Defined in header
 <a href="../../boost/counting_iterator.hpp">boost/counting_iterator.hpp</a>
 <p>
 How would you fill up a vector with the numbers zero
 through one hundred using <a
 href="http://www.sgi.com/tech/stl/copy.html"><tt>std::copy()</tt></a>? The
 only iterator operation missing from builtin integer types is an
 <tt>operator*()</tt> that returns the current
 value of the integer.  The counting iterator adaptor adds this crucial piece of
 functionality to whatever type it wraps. One can use the
 counting iterator adaptor not only with integer types, but with any
 type that is <tt>Incrementable</tt> (see type requirements <a href="#requirements">below</a>).  The
 following <b>pseudo-code</b> shows the general idea of how the
 counting iterator is implemented.
 </p>
 <pre>
  // inside a hypothetical counting_iterator class...
  typedef Incrementable value_type;
  value_type counting_iterator::operator*() const {
    return this->base; // no dereference!
  }
 </pre>
 All of the other operators of the counting iterator behave in the same
 fashion as the <tt>Incrementable</tt> base type.
 <h2>Synopsis</h2>
 <pre>
 namespace boost {
  template &lt;class Incrementable&gt;
  struct <a href="#counting_iterator_traits">counting_iterator_traits</a>;
  template &lt;class Incrementable&gt;
  struct <a href="#counting_iterator_generator">counting_iterator_generator</a>;
  template &lt;class Incrementable&gt;
  typename counting_iterator_generator&lt;Incrementable&gt;::type
  <a href="#make_counting_iterator">make_counting_iterator</a>(Incrementable x);
 }
 </pre>
 <hr>
 <h2><a name="counting_iterator_generator">The Counting Iterator Type
 Generator</a></h2>
 The class template <tt>counting_iterator_generator&lt;Incrementable&gt;</tt> is a <a href="../../more/generic_programming.html#type_generator">type generator</a> for counting iterators.
 <pre>
 template &lt;class Incrementable&gt;
 class counting_iterator_generator
 {
 public:
    typedef <a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt; type;
 };
 </pre>
 <h3>Example</h3>
 In this example we use the counting iterator generator to create a
 counting iterator, and count from zero to four.
 <pre>
 #include &lt;boost/config.hpp&gt;
 #include &lt;iostream&gt;
 #include &lt;boost/counting_iterator.hpp&gt;
 int main(int, char*[])
 {
  // Example of using counting_iterator_generator
  std::cout &lt;&lt; "counting from 0 to 4:" &lt;&lt; std::endl;
  boost::counting_iterator_generator&lt;int&gt;::type first(0), last(4);
  std::copy(first, last, std::ostream_iterator&lt;int&gt;(std::cout, " "));
  std::cout &lt;&lt; std::endl;
  // to be continued...
 </pre>
 The output from this part is:
 <pre>
 counting from 0 to 4:
 0 1 2 3 
 </pre>
 <h3>Template Parameters</h3>
 <Table border>
 <TR>
 <TH>Parameter</TH><TH>Description</TH>
 </TR>
 <TR>
 <TD><tt>Incrementable</tt></TD>
 <TD>The type being wrapped by the adaptor.</TD>
 </TR>
 </Table>
 <h3>Model of</h3>
 If the <tt>Incrementable</tt> type has all of the functionality of a
 <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
 Access Iterator</a> except the <tt>operator*()</tt>, then the counting
 iterator will be a model of <a
 href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
 Access Iterator</a>. If the <tt>Incrementable</tt> type has less
 functionality, then the counting iterator will have correspondingly
 less functionality.
 <h3><a name="requirements">Type Requirements</a></h3>
 The <tt>Incrementable</tt> type must be <a
 href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
 Constructible</a>, <a href="./CopyConstructible.html">Copy
 Constructible</a>, and <a href="./Assignable.html">Assignable</a>.
 Also, the <tt>Incrementable</tt> type must provide access to an
 associated <tt>difference_type</tt> and <tt>iterator_category</tt>
 through the <a
 href="#counting_iterator_traits"><tt>counting_iterator_traits</tt></a>
 class.
 <p>
 Furthermore, if you wish to create a counting iterator that is a <a
 href="http://www.sgi.com/tech/stl/ForwardIterator.html"> Forward
 Iterator</a>, then the following expressions must be valid:
 <pre>
 Incrementable i, j;
 ++i         // pre-increment
 i == j      // operator equal
 </pre>
 If you wish to create a counting iterator that is a <a
 href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">
 Bidirectional Iterator</a>, then pre-decrement is also required:
 <pre>
 --i
 </pre>
 If you wish to create a counting iterator that is a <a
 href="http://www.sgi.com/tech/stl/RandomAccessIterator.html"> Random
 Access Iterator</a>, then these additional expressions are also required:
 <pre>
 <a href="#counting_iterator_traits">counting_iterator_traits</a>&lt;Incrementable&gt;::difference_type n;
 i += n
 n = i - j
 i < j
 </pre>
 <h3>Members</h3>
 The counting iterator type implements the member functions and
 operators required of the <a
 href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
 Access Iterator</a> concept. In addition it has the following
 constructor:
 <pre>
 counting_iterator_generator::type(const Incrementable&amp; i)
 </pre>
 <p>
 <hr>
 <p>
 <h2><a name="make_counting_iterator">The Counting Iterator Object Generator</a></h2>
 <pre>
 template &lt;class Incrementable&gt;
 typename counting_iterator_generator&lt;Incrementable&gt;::type
 make_counting_iterator(Incrementable base);
 </pre>
 An <a href="../../more/generic_programming.html#object_generator">object
 generator</a> function that provides a convenient way to create counting
 iterators.<p>
 <h3>Example</h3>
 In this example we count from negative five to positive five, this
 time using the <tt>make_counting_iterator()</tt> function to save some
 typing.
 <pre>
  // continuing from previous example...
  std::cout &lt;&lt; "counting from -5 to 4:" &lt;&lt; std::endl;
  std::copy(boost::make_counting_iterator(-5),
 	    boost::make_counting_iterator(5),
 	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
  std::cout &lt;&lt; std::endl;
  // to be continued...
 </pre>
 The output from this part is:
 <pre>
 counting from -5 to 4:
 -5 -4 -3 -2 -1 0 1 2 3 4 
 </pre>
 In the next example we create an array of numbers, and then create a
 second array of pointers, where each pointer is the address of a
 number in the first array. The counting iterator makes it easy to do
 this since dereferencing a counting iterator that is wrapping an
 iterator over the array of numbers just returns a pointer to the
 current location in the array. We then use the <a
 href="./indirect_iterator.htm">indirect iterator adaptor</a> to print
 out the number in the array by accessing the numbers through the array
 of pointers.
 <pre>
  // continuing from previous example...
  const int N = 7;
  std::vector&lt;int&gt; 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&lt;std::vector&lt;int&gt;::iterator&gt; pointers;
  // Use counting iterator to fill in the array of pointers.
  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 &lt;&lt; "indirectly printing out the numbers from 0 to " 
 	    &lt;&lt; N &lt;&lt; std::endl;
  std::copy(boost::make_indirect_iterator(pointers.begin()),
 	    boost::make_indirect_iterator(pointers.end()),
 	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
  std::cout &lt;&lt; std::endl;
 </pre>
 The output is:
 <pre>
 indirectly printing out the numbers from 0 to 7
 0 1 2 3 4 5 6 
 </pre>
 <hr>
 <h2><a name="counting_iterator_traits">Counting Iterator Traits</a></h2>
 The counting iterator adaptor needs to determine the appropriate
 <tt>difference_type</tt> and <tt>iterator_category</tt> to use based on the
 <tt>Incrementable</tt> type supplied by the user.  The
 <tt>counting_iterator_traits</tt> class provides these types.  If the
 <tt>Incrementable</tt> type is an integral type or an iterator, these types
 will be correctly deduced by the <tt>counting_iterator_traits</tt> provided by
 the library. Otherwise, the user must specialize
 <tt>counting_iterator_traits</tt> for her type or add nested typedefs to
 her type to fulfill the needs of
 <a href="http://www.sgi.com/tech/stl/iterator_traits.html">
 <tt>std::iterator_traits</tt></a>.
 <p>The following pseudocode describes how the <tt>counting_iterator_traits</tt> are determined:
 <pre>
 template &lt;class Incrementable&gt;
 struct counting_iterator_traits
 {
  if (numeric_limits&lt;Incrementable&gt::is_specialized) {
    if (!numeric_limits&lt;Incrementable&gt::is_integer)
       COMPILE_TIME_ERROR;
    if (!numeric_limits&lt;Incrementable&gt::is_bounded
        &amp;&amp; numeric_limits&lt;Incrementable&gt;::is_signed) {
        typedef Incrementable difference_type;
    }
    else if (numeric_limits&lt;Incrementable&gt::is_integral) {
        typedef <i>next-larger-signed-type-or-intmax_t</i> difference_type;
    }
    typedef std::random_access_iterator_tag iterator_category;   
  } else {
    typedef std::iterator_traits&lt;Incrementable&gt;::difference_type difference_type;
    typedef std::iterator_traits&lt;Incrementable&gt;::iterator_category iterator_category;
  }
 };
 </pre>
 <p>The italicized sections above are implementation details, but it is important
 to know that the <tt>difference_type</tt> for integral types is selected so that
 it can always represent the difference between two values if such a built-in
 integer exists. On platforms with a working <tt>std::numeric_limits</tt>
 implementation, the <tt>difference_type</tt> for any variable-length signed
 integer type <tt>T</tt> is <tt>T</tt> itself.
 <hr>
 <p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" --></p>
 <p><EFBFBD> Copyright Jeremy Siek 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>
 </body>
 </html>
 <!--  LocalWords:  html charset alt gif hpp incrementable const namespace htm
 -->
 <!--  LocalWords:  struct  typename iostream int Siek CopyConstructible pre
 -->
--- a/counting_iterator_example.cpp
+++ b/counting_iterator_example.cpp
@ -1,57 +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 <iterator>
 #include <vector>
 #include <boost/counting_iterator.hpp>
 #include <boost/iterator_adaptors.hpp>
 int main(int, char*[])
 {
  // Example of using counting_iterator_generator
  std::cout << "counting from 0 to 4:" << std::endl;
  boost::counting_iterator_generator<int>::type 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.
  const 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
 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
  std::copy(boost::make_counting_iterator(numbers.begin()),
            boost::make_counting_iterator(numbers.end()),
            std::back_inserter(pointers));
 #endif 
 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
  // 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;
 #endif
  return 0;
 }
--- a/counting_iterator_test.cpp
+++ b/counting_iterator_test.cpp
@ -1,269 +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
 // 16 Feb 2001  Added a missing const. Made the tests run (somewhat) with
 //              plain MSVC again. (David Abrahams)
 // 11 Feb 2001  #if 0'd out use of counting_iterator on non-numeric types in
 //              MSVC without STLport, so that the other tests may proceed
 //              (David Abrahams)
 // 04 Feb 2001  Added use of iterator_tests.hpp (David Abrahams)
 // 28 Jan 2001  Removed not_an_iterator detritus (David Abrahams)
 // 24 Jan 2001  Initial revision (David Abrahams)
 #include <boost/config.hpp>
 #ifdef BOOST_MSVC
 # pragma warning(disable:4786) // identifier truncated in debug info
 #endif
 #include <boost/pending/iterator_tests.hpp>
 #include <boost/counting_iterator.hpp>
 #include <boost/detail/iterator.hpp>
 #include <iostream>
 #include <climits>
 #include <iterator>
 #include <stdlib.h>
 #ifndef __BORLANDC__
 # include <boost/tuple/tuple.hpp>
 #endif 
 #include <vector>
 #include <list>
 #include <cassert>
 #ifndef BOOST_NO_LIMITS
 # include <limits>
 #endif
 #ifndef BOOST_NO_SLIST
 # include <slist>
 #endif
 template <class T> struct is_numeric
 {
    enum { value = 
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
        std::numeric_limits<T>::is_specialized
 #else
        // Causes warnings with GCC, but how else can I detect numeric types at
        // compile-time?
        (boost::is_convertible<int,T>::value &&
         boost::is_convertible<T,int>::value)
 #endif
    };
 };
 // Special tests for RandomAccess CountingIterators.
 template <class CountingIterator>
 void category_test(
    CountingIterator start,
    CountingIterator finish,
    std::random_access_iterator_tag)
 {
    typedef typename
        boost::detail::iterator_traits<CountingIterator>::difference_type
        difference_type;
    difference_type distance = boost::detail::distance(start, finish);
    // Pick a random position internal to the range
    difference_type offset = (unsigned)rand() % distance;
    assert(offset >= 0);
    CountingIterator internal = start;
    std::advance(internal, offset);
    // Try some binary searches on the range to show that it's ordered
    assert(std::binary_search(start, finish, *internal));
    // #including tuple crashed borland, so I had to give up on tie().
    std::pair<CountingIterator,CountingIterator> xy(
        std::equal_range(start, finish, *internal));
    CountingIterator x = xy.first, y = xy.second;
    assert(boost::detail::distance(x, y) == 1);
    // Show that values outside the range can't be found
    assert(!std::binary_search(start, boost::prior(finish), *finish));
    // Do the generic random_access_iterator_test
    typedef typename CountingIterator::value_type value_type;
    std::vector<value_type> v;
    for (value_type z = *start; z != *finish; ++z)
        v.push_back(z);
    if (v.size() >= 2)
    {
        // Note that this test requires a that the first argument is
        // dereferenceable /and/ a valid iterator prior to the first argument
        boost::random_access_iterator_test(start + 1, v.size() - 1, v.begin() + 1);
    }
 }
 // Special tests for bidirectional CountingIterators
 template <class CountingIterator>
 void category_test(CountingIterator start, CountingIterator finish, std::bidirectional_iterator_tag)
 {
    if (finish != start
        && finish != boost::next(start)
        && finish != boost::next(boost::next(start)))
    {
        // Note that this test requires a that the first argument is
        // dereferenceable /and/ a valid iterator prior to the first argument
        boost::bidirectional_iterator_test(boost::next(start), boost::next(*start), boost::next(boost::next(*start)));
    }
 }
 template <class CountingIterator>
 void category_test(CountingIterator start, CountingIterator finish, std::forward_iterator_tag)
 {
    if (finish != start && finish != boost::next(start))
        boost::forward_iterator_test(start, *start, boost::next(*start));
 }
 template <class CountingIterator>
 void test_aux(CountingIterator start, CountingIterator finish)
 {
    typedef typename CountingIterator::iterator_category category;
    typedef typename CountingIterator::value_type value_type;
    // If it's a RandomAccessIterator we can do a few delicate tests
    category_test(start, finish, category());
    // Okay, brute force...
    for (CountingIterator p = start; p != finish && boost::next(p) != finish; ++p)
    {
        assert(boost::next(*p) == *boost::next(p));
    }
    // prove that a reference can be formed to these values
    typedef typename CountingIterator::value_type value;
    const value* q = &*start;
    (void)q; // suppress unused variable warning
 }
 template <class Incrementable>
 void test(Incrementable start, Incrementable finish)
 {
    test_aux(boost::make_counting_iterator(start), boost::make_counting_iterator(finish));
 }
 template <class Integer>
 void test_integer(Integer* = 0) // default arg works around MSVC bug
 {
    Integer start = 0;
    Integer finish = 120;
    test(start, finish);
 }
 template <class Container>
 void test_container(Container* = 0)  // default arg works around MSVC bug
 {
    Container c(1 + (unsigned)rand() % 1673);
    const typename Container::iterator start = c.begin();
    // back off by 1 to leave room for dereferenceable value at the end
    typename Container::iterator finish = start;
    std::advance(finish, c.size() - 1);
    test(start, finish);
    typedef typename Container::const_iterator const_iterator;
    test(const_iterator(start), const_iterator(finish));
 }
 class my_int1 {
 public:
  my_int1() { }
  my_int1(int x) : m_int(x) { }
  my_int1& operator++() { ++m_int; return *this; }
  bool operator==(const my_int1& x) const { return m_int == x.m_int; }
 private:
  int m_int;
 };
 namespace boost {
  template <>
  struct counting_iterator_traits<my_int1> {
    typedef std::ptrdiff_t difference_type;
    typedef std::forward_iterator_tag iterator_category;
  };
 }
 class my_int2 {
 public:
  typedef void value_type;
  typedef void pointer;
  typedef void reference;
  typedef std::ptrdiff_t difference_type;
  typedef std::bidirectional_iterator_tag iterator_category;
  my_int2() { }
  my_int2(int x) : m_int(x) { }
  my_int2& operator++() { ++m_int; return *this; }
  my_int2& operator--() { --m_int; return *this; }
  bool operator==(const my_int2& x) const { return m_int == x.m_int; }
 private:
  int m_int;
 };
 class my_int3 {
 public:
  typedef void value_type;
  typedef void pointer;
  typedef void reference;
  typedef std::ptrdiff_t difference_type;
  typedef std::random_access_iterator_tag iterator_category;
  my_int3() { }
  my_int3(int x) : m_int(x) { }
  my_int3& operator++() { ++m_int; return *this; }
  my_int3& operator+=(std::ptrdiff_t n) { m_int += n; return *this; }
  std::ptrdiff_t operator-(const my_int3& x) const { return m_int - x.m_int; }
  my_int3& operator--() { --m_int; return *this; }
  bool operator==(const my_int3& x) const { return m_int == x.m_int; }
  bool operator!=(const my_int3& x) const { return m_int != x.m_int; }
  bool operator<(const my_int3& x) const { return m_int < x.m_int; }
 private:
  int m_int;
 };
 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
   // wrapping an iterator or non-built-in integer type causes an INTERNAL
   // COMPILER ERROR in MSVC without STLport. I'm clueless as to why.
 #if !defined(BOOST_MSVC) || BOOST_MSVC > 1200 || defined(__SGI_STL_PORT)
    // Test user-defined type.
    test_integer<my_int1>();
    test_integer<my_int2>();
    test_integer<my_int3>();
   // 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];
    test(boost::make_counting_iterator(array), boost::make_counting_iterator(array+2000-1));
 #endif
    std::cout << "test successful " << std::endl;
    return 0;
 }
--- a/current_function.html
+++ b/current_function.html
@ -0,0 +1,36 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <html>
 	<head>
 		<title>Boost: current_function.hpp documentation</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
 	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
 		<table border="0" width="100%">
 			<tr>
 				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
 				</td>
 				<td align="center">
 					<h1>current_function.hpp</h1>
 				</td>
 			</tr>
 			<tr>
 				<td colspan="2" height="64">&nbsp;</td>
 			</tr>
 		</table>
 		<p>
 			The header <STRONG>&lt;boost/current_function.hpp&gt;</STRONG> defines a single 
 			macro, <STRONG>BOOST_CURRENT_FUNCTION</STRONG>,<STRONG> </STRONG>similar to the 
 			C99 predefined identifier <STRONG>__func__</STRONG>.
 		</p>
 		<P><STRONG>BOOST_CURRENT_FUNCTION</STRONG> expands to a string literal containing 
 			the (fully qualified, if possible) name of the enclosing function. If there is 
 			no enclosing function, the behavior is undefined.</P>
 		<p>Some compilers do not provide a way to obtain the name of the current enclosing 
 			function. On such compilers, the string literal has an unspecified value.</p>
 		<p>
 			<br>
 			<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
@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
 #if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion
@ -10,18 +12,22 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  Permission to copy, use, modify, sell and distribute this software
+// Distributed under the Boost Software License, Version 1.0. (See
-//  is granted provided this copyright notice appears in all copies.
+// accompanying file LICENSE_1_0.txt or copy at
-//  This software is provided "as is" without express or implied
+// http://www.boost.org/LICENSE_1_0.txt)
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 #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)
@ -29,4 +35,6 @@ void message(char const * file, long line, char const * func, char const * msg)
 int main()
 {
    MESSAGE("assertion failed");
    return 0;
 }
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -0,0 +1,68 @@
 # Copyright John Maddock 2005. Use, modification, and distribution are
 # subject to the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 project : requirements
        # Path for links to Boost:
        <xsl:param>boost.root=../../../..
        # Some general style settings:
        <xsl:param>table.footnote.number.format=1
        <xsl:param>footnote.number.format=1
        # HTML options first:
        # Use graphics not text for navigation:
        <xsl:param>navig.graphics=1
       # PDF Options:
        # TOC Generation: this is needed for FOP-0.9 and later:
        <xsl:param>fop1.extensions=0
        <xsl:param>xep.extensions=1
        # TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
        <xsl:param>fop.extensions=0
        # No indent on body text:
        <xsl:param>body.start.indent=0pt
        # Margin size:
        <xsl:param>page.margin.inner=0.5in
        # Margin size:
        <xsl:param>page.margin.outer=0.5in
        # Paper type = A4
        <xsl:param>paper.type=A4
        # Yes, we want graphics for admonishments:
        <xsl:param>admon.graphics=1
        # Set this one for PDF generation *only*:
        # default pnd graphics are awful in PDF form,
        # better use SVG's instead:
        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/utility/doc/html
 ;
 using quickbook ;
 path-constant boost-images : ../../../doc/src/images ;
 xml declval : declval.qbk ;
 boostbook standalone
    :
        declval
    :
        # File name of HTML output:
        <xsl:param>root.filename=declval
        # How far down we chunk nested sections, basically all of them:
        <xsl:param>chunk.section.depth=0
        # Don't put the first section on the same page as the TOC:
        <xsl:param>chunk.first.sections=0
        # How far down sections get TOC's
        <xsl:param>toc.section.depth=1
        # Max depth in each TOC:
        <xsl:param>toc.max.depth=1
        # How far down we go with TOC's
        <xsl:param>generate.section.toc.level=1
     ;
--- a/doc/declval.qbk
+++ b/doc/declval.qbk
@ -0,0 +1,104 @@
 [/
 / Copyright (c) 2008 Howard Hinnant
 / Copyright (c) 2008 Beman Dawes
 / Copyright (c) 2009-20010 Vicente J. Botet Escriba
 /
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 /]
 [article Declval
    [quickbook 1.5]
    [authors [Hinnant, Howard]]
    [authors [Dawes, Beman]]
    [authors [Botet Escriba, Vicente J.]]
    [copyright 2008 Howard Hinnant]
    [copyright 2008 Beman Dawes]
    [copyright 2009-2010 Vicente J. Botet Escriba]
    [license
        Distributed under the Boost Software License, Version 1.0.
        (See accompanying file LICENSE_1_0.txt or copy at
        [@http://www.boost.org/LICENSE_1_0.txt])
    ]
 ]
 [/===============]
 [section Overview]
 [/===============]
 The motivation for `declval` was introduced in [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2958.html#Value N2958: 
 Moving Swap Forward]. Here follows a rewording of this chapter.
 With the provision of decltype, late-specified return types, and default template-arguments for function templates a 
 new generation of SFINAE patterns will emerge to at least partially compensate the lack of concepts on the C++0x timescale. 
 Using this technique, it is sometimes necessary to obtain an object of a known type in a non-using context, e.g. given the declaration 
  template<class T>
  T&& declval(); // not used
 as part of the function template declaration 
  template<class To, class From>
  decltype(static_cast<To>(declval<From>())) convert(From&&);
 or as part of a class template definition 
  template<class> class result_of;
  template<class Fn, class... ArgTypes>
  struct result_of<Fn(ArgTypes...)> 
  {
    typedef decltype(declval<Fn>()(declval<ArgTypes>()...)) type;
  };
 The role of the function template declval() is a transformation of a type T into a value without using or evaluating this function. 
 The name is supposed to direct the reader's attention to the fact that the expression `declval<T>()` is an lvalue if and only if 
 T is an lvalue-reference, otherwise an rvalue. To extend the domain of this function we can do a bit better by changing its declaration to 
  template<class T>
  typename std::add_rvalue_reference<T>::type declval(); // not used
 which ensures that we can also use cv void as template parameter. The careful reader might have noticed that `declval()` 
 already exists under the name create() as part of the definition of the semantics of the type trait is_convertible in the C==0x standard. 
 The provision of a new library component that allows the production of values in unevaluated expressions is considered as 
 important to realize constrained templates in C++0x where concepts are not available. 
 This extremely light-weight function is expected to be part of the daily tool-box of the C++0x programmer. 
 [endsect]
 [/=================]
 [section:reference Reference ]
 [/=================]
 `#include <boost/utility/declval.hpp>`
    namespace boost {
        template <typename T>
        typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand
    }  // namespace boost
 The library provides the function template declval to simplify the definition of expressions which occur as unevaluated operands.
        template <typename T>
        typename add_rvalue_reference<T>::type declval();
 [*Remarks:] If this function is used, the program is ill-formed.
 [*Remarks:] The template parameter T of declval may be an incomplete type.
 [*Example:]
    template <class To, class From>
    decltype(static_cast<To>(declval<From>())) convert(From&&);
 Declares a function template convert which only participats in overloading if the type From can be explicitly converted to type To. 
 [endsect]
--- a/doc/html/declval.html
+++ b/doc/html/declval.html
@ -0,0 +1,163 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
 <title>Declval</title>
 <link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
 <link rel="home" href="declval.html" title="Declval">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
 <td align="center"><a href="../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
 <div class="spirit-nav"></div>
 <div class="article" lang="en">
 <div class="titlepage">
 <div>
 <div><h2 class="title">
 <a name="declval"></a>Declval</h2></div>
 <div><div class="authorgroup">
 <div class="author"><h3 class="author">
 <span class="firstname">Howard</span> <span class="surname">Hinnant</span>
 </h3></div>
 <div class="author"><h3 class="author">
 <span class="firstname">Beman</span> <span class="surname">Dawes</span>
 </h3></div>
 <div class="author"><h3 class="author">
 <span class="firstname">Vicente J.</span> <span class="surname">Botet Escriba</span>
 </h3></div>
 </div></div>
 <div><p class="copyright">Copyright &#169; 2008 Howard Hinnant</p></div>
 <div><p class="copyright">Copyright &#169; 2008 Beman Dawes</p></div>
 <div><p class="copyright">Copyright &#169; 2009 -2010 Vicente J. Botet Escriba</p></div>
 <div><div class="legalnotice">
 <a name="id879409"></a><p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
 </div></div>
 </div>
 <hr>
 </div>
 <div class="toc">
 <p><b>Table of Contents</b></p>
 <dl>
 <dt><span class="section"><a href="declval.html#declval.overview">Overview</a></span></dt>
 <dt><span class="section"><a href="declval.html#declval.reference"> Reference </a></span></dt>
 </dl>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="declval.overview"></a><a class="link" href="declval.html#declval.overview" title="Overview">Overview</a>
 </h2></div></div></div>
 <p>
      The motivation for <code class="computeroutput"><span class="identifier">declval</span></code>
      was introduced in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2958.html#Value" target="_top">N2958:
      Moving Swap Forward</a>. Here follows a rewording of this chapter.
    </p>
 <p>
      With the provision of decltype, late-specified return types, and default template-arguments
      for function templates a new generation of SFINAE patterns will emerge to at
      least partially compensate the lack of concepts on the C++0x timescale. Using
      this technique, it is sometimes necessary to obtain an object of a known type
      in a non-using context, e.g. given the declaration
    </p>
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">declval</span><span class="special">();</span> <span class="comment">// not used
 </span></pre>
 <p>
      as part of the function template declaration
    </p>
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">To</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">From</span><span class="special">&gt;</span>
 <span class="identifier">decltype</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">To</span><span class="special">&gt;(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">&gt;()))</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">From</span><span class="special">&amp;&amp;);</span>
 </pre>
 <p>
      or as part of a class template definition
    </p>
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">result_of</span><span class="special">;</span>
 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Fn</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">ArgTypes</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">result_of</span><span class="special">&lt;</span><span class="identifier">Fn</span><span class="special">(</span><span class="identifier">ArgTypes</span><span class="special">...)&gt;</span> 
 <span class="special">{</span>
  <span class="keyword">typedef</span> <span class="identifier">decltype</span><span class="special">(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">Fn</span><span class="special">&gt;()(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">ArgTypes</span><span class="special">&gt;()...))</span> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
 <p>
      The role of the function template declval() is a transformation of a type T
      into a value without using or evaluating this function. The name is supposed
      to direct the reader's attention to the fact that the expression <code class="computeroutput"><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;()</span></code> is
      an lvalue if and only if T is an lvalue-reference, otherwise an rvalue. To
      extend the domain of this function we can do a bit better by changing its declaration
      to
    </p>
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">();</span> <span class="comment">// not used
 </span></pre>
 <p>
      which ensures that we can also use cv void as template parameter. The careful
      reader might have noticed that <code class="computeroutput"><span class="identifier">declval</span><span class="special">()</span></code> already exists under the name create() as
      part of the definition of the semantics of the type trait is_convertible in
      the C==0x standard.
    </p>
 <p>
      The provision of a new library component that allows the production of values
      in unevaluated expressions is considered as important to realize constrained
      templates in C++0x where concepts are not available. This extremely light-weight
      function is expected to be part of the daily tool-box of the C++0x programmer.
    </p>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="declval.reference"></a><a class="link" href="declval.html#declval.reference" title="Reference"> Reference </a>
 </h2></div></div></div>
 <p>
      <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">declval</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
    </p>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
    <span class="keyword">typename</span> <span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">();</span> <span class="comment">//noexcept; // as unevaluated operand
 </span>
 <span class="special">}</span>  <span class="comment">// namespace boost
 </span></pre>
 <p>
      The library provides the function template declval to simplify the definition
      of expressions which occur as unevaluated operands.
    </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">typename</span> <span class="identifier">add_rvalue_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">declval</span><span class="special">();</span>
 </pre>
 <p>
      <span class="bold"><strong>Remarks:</strong></span> If this function is used, the program
      is ill-formed.
    </p>
 <p>
      <span class="bold"><strong>Remarks:</strong></span> The template parameter T of declval
      may be an incomplete type.
    </p>
 <p>
      <span class="bold"><strong>Example:</strong></span>
    </p>
 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">To</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">From</span><span class="special">&gt;</span>
 <span class="identifier">decltype</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">To</span><span class="special">&gt;(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">&gt;()))</span> <span class="identifier">convert</span><span class="special">(</span><span class="identifier">From</span><span class="special">&amp;&amp;);</span>
 </pre>
 <p>
      Declares a function template convert which only participats in overloading
      if the type From can be explicitly converted to type To.
    </p>
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"><p><small>Last revised: September 16, 2010 at 16:19:10 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
 <div class="spirit-nav"></div>
 </body>
 </html>
--- a/enable_if.html
+++ b/enable_if.html
@ -0,0 +1,389 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
            "http://www.w3.org/TR/REC-html40/loose.dtd">
 <HTML>
 <HEAD><TITLE>enable_if</TITLE>
 <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
 <META name="GENERATOR" content="Microsoft FrontPage 5.0">
 </HEAD>
 <BODY >
 <!--HEVEA command line is: hevea -nosymb -noiso -pedantic -v enable_if_docs_for_boost.tex -->
 <!--HTMLHEAD-->
 <!--ENDHTML-->
 <!--PREFIX <ARG ></ARG>-->
 <!--CUT DEF section 1 -->
 <BR>
 <BR>
 <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>
 <BR>
 <!--TOC section Introduction-->
 <H2><A NAME="htoc1">1</A>&nbsp;&nbsp;Introduction</H2><!--SEC END -->
 <A NAME="introduction"></A>
 The <TT>enable_if</TT> family of templates is a set of tools to allow a function template or a class template specialization 
 to include or exclude itself from a set of matching functions or specializations
 based on properties of its template arguments. 
 For example, one can define function templates that
 are only enabled for, and thus only match, an arbitrary set of types
 defined by a traits class. The <TT>enable_if</TT> templates can also be
 applied to enable class template specializations. Applications of
 <TT>enable_if</TT> are discussed in length
 in&nbsp;[<A HREF="#jarvi:03:cuj_arbitrary_overloading"><CITE>1</CITE></A>] and&nbsp;[<A HREF="#jarvi:03:c++typeclasses"><CITE>2</CITE></A>].<BR>
 <BR>
 <!--TOC subsection Synopsis-->
 <H3><A NAME="htoc2">1.1</A>&nbsp;&nbsp;Synopsis</H3><!--SEC END -->
 <A NAME="sec:synopsis"></A>
 <PRE>namespace boost {
  template &lt;class Cond, class T = void&gt; struct enable_if;
  template &lt;class Cond, class T = void&gt; struct disable_if;
  template &lt;class Cond, class T&gt; struct lazy_enable_if;
  template &lt;class Cond, class T&gt; struct lazy_disable_if;
  template &lt;bool B, class T = void&gt; struct enable_if_c;
  template &lt;bool B, class T = void&gt; struct disable_if_c;
  template &lt;bool B, class T&gt; struct lazy_enable_if_c;
  template &lt;bool B, class T&gt; struct lazy_disable_if_c;
 }
 </PRE>
 <!--TOC subsection Background-->
 <H3><A NAME="htoc3">1.2</A>&nbsp;&nbsp;Background</H3><!--SEC END -->
 <A NAME="sec:background"></A>
 Sensible operation of template function overloading in C++ relies
 on the <EM>SFINAE</EM> (substitution-failure-is-not-an-error)
 principle&nbsp;[<A HREF="#vandevoorde2002:templates"><CITE>3</CITE></A>]: if an invalid argument
 or return type is formed during the instantiation of a function
 template, the instantiation is removed from the overload resolution
 set instead of causing a compilation error. The following example, 
 taken from&nbsp;[<A HREF="#jarvi:03:cuj_arbitrary_overloading"><CITE>1</CITE></A>],
 demonstrates why this is important:
 <PRE>int negate(int i) { return -i; }
 template &lt;class F&gt;
 typename F::result_type negate(const F&amp; f) { return -f(); }
 </PRE>
 Suppose the compiler encounters the call <TT>negate(1)</TT>. The first
 definition is obviously a better match, but the compiler must
 nevertheless consider (and instantiate the prototypes) of both
 definitions to find this out. Instantiating the latter definition with
 <TT>F</TT> as <TT>int</TT> would result in:
 <PRE>int::result_type negate(const int&amp;);
 </PRE>
 where the return type is invalid. If this was an error, adding an unrelated function template 
 (that was never called) could break otherwise valid code.
 Due to the SFINAE principle the above example is not, however, erroneous. 
 The latter definition of <TT>negate</TT> is simply removed from the overload resolution set.<BR>
 <BR>
 The <TT>enable_if</TT> templates are tools for controlled creation of the SFINAE
 conditions.<BR>
 <BR>
 <!--TOC section The <TT>enable_if</TT> templates-->
 <H2><A NAME="htoc4">2</A>&nbsp;&nbsp;The <TT>enable_if</TT> templates</H2><!--SEC END -->
 <A NAME="enable_if"></A>
 The names of the <TT>enable_if</TT> templates have three parts: an optional <TT>lazy_</TT> tag, 
 either <TT>enable_if</TT> or <TT>disable_if</TT>, and an optional <TT>_c</TT> tag.
 All eight combinations of these parts are supported.
 The meaning of the <TT>lazy_</TT> tag is described in Section&nbsp;<A HREF="#sec:enable_if_lazy">3.3</A>.
 The second part of the name indicates whether a true condition argument should 
 enable or disable the current overload.
 The third part of the name indicates whether the condition argument is a <TT>bool</TT> value 
 (<TT>_c</TT> suffix), or a type containing a static <TT>bool</TT> constant named <TT>value</TT> (no suffix).
 The latter version interoperates with Boost.MPL. <BR>
 <BR>
 The definitions of <TT>enable_if_c</TT> and <TT>enable_if</TT> are as follows (we use <TT>enable_if</TT> templates 
 unqualified but they are in the <TT>boost</TT> namespace).
 <PRE>template &lt;bool B, class T = void&gt;
 struct enable_if_c {
  typedef T type;
 };
 template &lt;class T&gt;
 struct enable_if_c&lt;false, T&gt; {};
 template &lt;class Cond, class T = void&gt;
 struct enable_if : public enable_if_c&lt;Cond::value, T&gt; {};
 </PRE>
 An instantiation of the <TT>enable_if_c</TT> template with the parameter
 <TT>B</TT> as <TT>true</TT> contains a member type <TT>type</TT>, defined
 to be <TT>T</TT>. If <TT>B</TT> is
 <TT>false</TT>, no such member is defined. Thus 
 <TT>enable_if_c&lt;B, T&gt;::type</TT> is either a valid or an invalid type
 expression, depending on the value of <TT>B</TT>.
 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="../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; }
 </PRE>
 The <TT>disable_if_c</TT> template is provided as well, and has the
 same functionality as <TT>enable_if_c</TT> except for the negated condition. The following
 function is enabled for all non-arithmetic types.
 <PRE>template &lt;class T&gt;
 typename disable_if_c&lt;boost::is_arithmetic&lt;T&gt;::value, T&gt;::type 
 bar(T t) { return t; }
 </PRE>
 For easier syntax in some cases and interoperation with Boost.MPL we provide versions of
 the <TT>enable_if</TT> templates taking any type with a <TT>bool</TT> member constant named 
 <TT>value</TT> as the condition argument.
 The MPL <TT>bool_</TT>, <TT>and_</TT>, <TT>or_</TT>, and <TT>not_</TT> templates are likely to be 
 useful for creating such types. Also, the traits classes in the Boost.Type_traits library 
 follow this convention. 
 For example, the above example function <TT>foo</TT> can be alternatively written as:
 <PRE>template &lt;class T&gt;
 typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
 foo(T t) { return t; }
 </PRE>
 <!--TOC section Using <TT>enable_if</TT>-->
 <H2><A NAME="htoc5">3</A>&nbsp;&nbsp;Using <TT>enable_if</TT></H2><!--SEC END -->
 <A NAME="sec:using_enable_if"></A>
 The <TT>enable_if</TT> templates are defined in
 <TT>boost/utility/enable_if.hpp</TT>, which is included by <TT>boost/utility.hpp</TT>.<BR>
 <BR>
 The <TT>enable_if</TT> template can be used either as the return type, or as an 
 extra argument. For example, the <TT>foo</TT> function in the previous section could also be written
 as:
 <PRE>template &lt;class T&gt;
 T foo(T t, typename enable_if&lt;boost::is_arithmetic&lt;T&gt; &gt;::type* dummy = 0); 
 </PRE>Hence, an extra parameter of type <TT>void*</TT> is added, but it is given 
 a default value to keep the parameter hidden from client code.
 Note that the second template argument was not given to <TT>enable_if</TT>, as the default 
 <TT>void</TT> gives the desired behavior.<BR>
 <BR>
 Whether to write the enabler as an argument or within the return type is
 largely a matter of taste, but for certain functions, only one
 alternative is possible:
 <UL><LI>
 Operators have a fixed number of arguments, thus <TT>enable_if</TT> must be used in the return type.
 <LI>Constructors and destructors do not have a return type; an extra argument is the only option.
 <LI>There does not seem to be a way to specify an enabler for a conversion operator. Converting constructors,
 however, can have enablers as extra default arguments.
 </UL>
 <!--TOC subsection Enabling template class specializations-->
 <H3><A NAME="htoc6">3.1</A>&nbsp;&nbsp;Enabling template class specializations</H3><!--SEC END -->
 <A NAME="sec:enable_if_classes"></A>
 Class template specializations can be enabled or disabled with <TT>enable_if</TT>.
 One extra template parameter needs to be added for the enabler expressions.
 This parameter has the default value <TT>void</TT>.
 For example:
 <PRE>template &lt;class T, class Enable = void&gt; 
 class A { ... };
 template &lt;class T&gt;
 class A&lt;T, typename enable_if&lt;is_integral&lt;T&gt; &gt;::type&gt; { ... };
 template &lt;class T&gt;
 class A&lt;T, typename enable_if&lt;is_float&lt;T&gt; &gt;::type&gt; { ... };
 </PRE>Instantiating <TT>A</TT> with any integral type matches the first specialization,
 whereas any floating point type matches the second one. All other types
 match the primary template.
 The condition can be any compile-time boolean expression that depends on the 
 template arguments of the class.
 Note that again, the second argument to <TT>enable_if</TT> is not needed; the default (<TT>void</TT>) 
 is the correct value.<BR>
 <BR>
 <!--TOC subsection Overlapping enabler conditions-->
 <H3><A NAME="htoc7">3.2</A>&nbsp;&nbsp;Overlapping enabler conditions</H3><!--SEC END -->
 <A NAME="sec:overlapping_conditions"></A>
 Once the compiler has examined the enabling conditions and included the
 function into the overload resolution set, normal C++ overload resolution 
 rules are used to select the best matching function.
 In particular, there is no ordering between enabling conditions.
 Function templates with enabling conditions that are not mutually exclusive can 
 lead to ambiguities. For example:
 <PRE>template &lt;class T&gt;
 typename enable_if&lt;boost::is_integral&lt;T&gt;, void&gt;::type 
 foo(T t) {}
 template &lt;class T&gt;
 typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, void&gt;::type 
 foo(T t) {}
 </PRE>
 All integral types are also arithmetic. Therefore, say, for the call <TT>foo(1)</TT>,
 both conditions are true and both functions are thus in the overload resolution set.
 They are both equally good matches and thus ambiguous.
 Of course, more than one enabling condition can be simultaneously true as long as 
 other arguments disambiguate the functions.<BR>
 <BR>
 The above discussion applies to using <TT>enable_if</TT> in class template
 partial specializations as well.<BR>
 <BR>
 <!--TOC subsection Lazy <TT>enable_if</TT>-->
 <H3><A NAME="htoc8">3.3</A>&nbsp;&nbsp;Lazy <TT>enable_if</TT></H3><!--SEC END -->
 <A NAME="sec:enable_if_lazy"></A>
 In some cases it is necessary to avoid instantiating part of a
 function signature unless an enabling condition is true. For example:
 <PRE>template &lt;class T, class U&gt; class mult_traits;
 template &lt;class T, class U&gt;
 typename enable_if&lt;is_multipliable&lt;T, U&gt;, typename mult_traits&lt;T, U&gt;::type&gt;::type
 operator*(const T&amp; t, const U&amp; u) { ... }
 </PRE>Assume the class template <TT>mult_traits</TT> is a traits class defining 
 the resulting type of a multiplication operator. The <TT>is_multipliable</TT> traits
 class specifies for which types to enable the operator. Whenever
 <TT>is_multipliable&lt;A, B&gt;::value</TT> is <TT>true</TT> for some types <TT>A</TT> and <TT>B</TT>,
 then <TT>mult_traits&lt;A, B&gt;::type</TT> is defined.<BR>
 <BR>
 Now, trying to invoke (some other overload) of <TT>operator*</TT> with, say, operand types <TT>C</TT> and <TT>D</TT> 
 for which <TT>is_multipliable&lt;C, D&gt;::value</TT> is <TT>false</TT> 
 and <TT>mult_traits&lt;C, D&gt;::type</TT> is not defined is an error on some compilers. 
 The SFINAE principle is not applied because
 the invalid type occurs as an argument to another template. The <TT>lazy_enable_if</TT> 
 and <TT>lazy_disable_if</TT> templates (and their <TT>_c</TT> versions) can be used in such
 situations:
 <PRE>template&lt;class T, class U&gt;
 typename lazy_enable_if&lt;is_multipliable&lt;T, U&gt;, mult_traits&lt;T, U&gt; &gt;::type
 operator*(const T&amp; t, const U&amp; u) { ... }
 </PRE>The second argument of <TT>lazy_enable_if</TT> must be a class type
 that defines a nested type named <TT>type</TT> whenever the first
 parameter (the condition) is true.<BR>
 <BR>
 <!--TOC paragraph Note-->
 <H5>Note</H5><!--SEC END -->
 Referring to one member type or static constant in a traits class
 causes all of the members (type and static constant) of that
 specialization to be instantiated. Therefore, if your traits classes
 can sometimes contain invalid types, you should use two distinct
 templates for describing the conditions and the type mappings. In the
 above example, <TT>is_multipliable&lt;T, U&gt;::value</TT> defines when
 <TT>mult_traits&lt;T, U&gt;::type</TT> is valid.<BR>
 <BR>
 <!--TOC subsection Compiler workarounds-->
 <H3><A NAME="htoc9">3.4</A>&nbsp;&nbsp;Compiler workarounds</H3><!--SEC END -->
 <A NAME="sec:workarounds"></A>
 Some compilers flag functions as ambiguous if the only distinguishing factor is a different 
 condition in an enabler (even though the functions could never be ambiguous). For example,
 some compilers (e.g. GCC 3.2) diagnose the following two functions as ambiguous:
 <PRE>template &lt;class T&gt;
 typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
 foo(T t);
 template &lt;class T&gt;
 typename disable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
 foo(T t);
 </PRE>Two workarounds can be applied:
 <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;int&gt; struct dummy { dummy(int) {} };
 template &lt;class T&gt;
 typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
 foo(T t, dummy&lt;0&gt; = 0);
 template &lt;class T&gt;
 typename disable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
 foo(T t, dummy&lt;1&gt; = 0);
 </PRE><BR>
 <BR>
 <LI>Define the functions in different namespaces and bring them into a common
 namespace with <TT>using</TT> declarations:
 <PRE>namespace A {
  template &lt;class T&gt;
  typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
  foo(T t);
 }
 namespace B {
  template &lt;class T&gt;
  typename disable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
  foo(T t);
 }
 using A::foo;
 using B::foo;
 </PRE>
 Note that the second workaround above cannot be used for member
 templates. On the other hand, operators do not accept extra arguments,
 which makes the first workaround unusable. As the net effect,
 neither of the workarounds are of assistance for templated operators that
 need to be defined as member functions (assignment and
 subscript operators).
 </UL>
 <!--TOC section Acknowledgements-->
 <H2><A NAME="htoc10">4</A>&nbsp;&nbsp;Acknowledgements</H2><!--SEC END -->
 We are grateful to Howard Hinnant, Jason Shirk, Paul Mensonides, and Richard
 Smith whose findings have influenced the library.<BR>
 <BR>
 <!--TOC section References-->
 <H2>References</H2><!--SEC END -->
 <DL COMPACT=compact><DT><A NAME="jarvi:03:cuj_arbitrary_overloading"><FONT COLOR=purple>[1]</FONT></A><DD>
 Jaakko J&auml;rvi, Jeremiah Willcock, Howard Hinnant, and Andrew Lumsdaine.
 Function overloading based on arbitrary properties of types.
 <EM>C/C++ Users Journal</EM>, 21(6):25--32, June 2003.<BR>
 <BR>
 <DT><A NAME="jarvi:03:c++typeclasses"><FONT COLOR=purple>[2]</FONT></A><DD>
 Jaakko J&auml;rvi, Jeremiah Willcock, and Andrew Lumsdaine.
 Concept-controlled polymorphism.
 In Frank Pfennig and Yannis Smaragdakis, editors, <EM>Generative
 Programming and Component Engineering</EM>, volume 2830 of <EM>LNCS</EM>, pages
 228--244. Springer Verlag, September 2003.<BR>
 <BR>
 <DT><A NAME="vandevoorde2002:templates"><FONT COLOR=purple>[3]</FONT></A><DD>
 David Vandevoorde and Nicolai&nbsp;M. Josuttis.
 <EM>C++ Templates: The Complete Guide</EM>.
 Addison-Wesley, 2002.</DL>
 <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<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-->
 <HR SIZE=2>
 <BLOCKQUOTE><EM>This document was translated from L<sup>A</sup>T<sub>E</sub>X by
 </EM><A HREF="http://pauillac.inria.fr/~maranget/hevea/index.html"><EM>H<FONT SIZE=2><sup>E</sup></FONT>V<FONT SIZE=2><sup>E</sup></FONT>A</EM></A><EM>.
 </EM></BLOCKQUOTE>
 </BODY>
 </HTML>
--- 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
@ -0,0 +1,62 @@
 // Boost enable_if library
 // Copyright 2003 (c) The Trustees of Indiana University.
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 #include <boost/test/minimal.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits.hpp>
 using boost::enable_if;
 using boost::disable_if;
 using boost::is_arithmetic;
 struct container {
  bool my_value;
  template <class T>
  container(const T&, const typename enable_if<is_arithmetic<T>, T>::type * = 0):
  my_value(true) {}
  template <class T>
  container(const T&, const typename disable_if<is_arithmetic<T>, T>::type * = 0):
  my_value(false) {}
 };
 // example from Howard Hinnant (tests enable_if template members of a templated class)
 template <class charT>
 struct xstring
 {
  template <class It>
  xstring(It begin, It end, typename 
          disable_if<is_arithmetic<It> >::type* = 0)
    : data(end-begin) {}
  int data;
 };
 int test_main(int, char*[])
 {
  BOOST_CHECK(container(1).my_value);
  BOOST_CHECK(container(1.0).my_value);
  BOOST_CHECK(!container("1").my_value);  
  BOOST_CHECK(!container(static_cast<void*>(0)).my_value);  
  char sa[] = "123456";
  BOOST_CHECK(xstring<char>(sa, sa+6).data == 6);
  return 0;
 }
--- a/enable_if/test/dummy_arg_disambiguation.cpp
+++ b/enable_if/test/dummy_arg_disambiguation.cpp
@ -0,0 +1,46 @@
 // Boost enable_if library
 // Copyright 2003 (c) The Trustees of Indiana University.
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 #include <boost/test/minimal.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 using boost::enable_if;
 using boost::disable_if;
 using boost::is_arithmetic;
 template <int N> struct dummy {
  dummy(int) {};
 };
 template<class T>
 typename enable_if<is_arithmetic<T>, bool>::type
 arithmetic_object(T t, dummy<0> = 0) { return true; }
 template<class T>
 typename disable_if<is_arithmetic<T>, bool>::type
 arithmetic_object(T t, dummy<1> = 0) { return false; }
 int test_main(int, char*[])
 {
  BOOST_CHECK(arithmetic_object(1));
  BOOST_CHECK(arithmetic_object(1.0));
  BOOST_CHECK(!arithmetic_object("1"));  
  BOOST_CHECK(!arithmetic_object(static_cast<void*>(0)));  
  return 0;
 }
--- a/enable_if/test/lazy.cpp
+++ b/enable_if/test/lazy.cpp
@ -0,0 +1,82 @@
 // Boost enable_if library
 // Copyright 2003 (c) The Trustees of Indiana University.
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 #include <boost/test/minimal.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 using boost::enable_if_c;
 using boost::lazy_enable_if_c;
 // This class provides a reduced example of a traits class for
 // computing the result of multiplying two types.  The member typedef
 // 'type' in this traits class defines the return type of this
 // operator.  The return type member is invalid unless both arguments
 // for mult_traits are values that mult_traits expects (ints in this
 // case).  This kind of situation may arise if a traits class only
 // makes sense for some set of types, not all C++ types.
 template <class T> struct is_int {
  BOOST_STATIC_CONSTANT(bool, value = (boost::is_same<T, int>::value));
 };
 template <class T, class U>
 struct mult_traits {
  typedef typename T::does_not_exist type;
 };
 template <>
 struct mult_traits<int, int> {
  typedef int type;
 };
 // Next, a forwarding function mult() is defined.  It is enabled only
 // when both arguments are of type int.  The first version, using
 // non-lazy enable_if_c does not work.
 #if 0
 template <class T, class U>
 typename enable_if_c<
  is_int<T>::value && is_int<U>::value,
  typename mult_traits<T, U>::type
 >::type
 mult(const T& x, const U& y) {return x * y;}
 #endif
 // A correct version uses lazy_enable_if_c.
 // This template removes compiler errors from invalid code used as an
 // argument to enable_if_c.
 #if 1
 template <class T, class U>
 typename lazy_enable_if_c<
  is_int<T>::value & is_int<U>::value,
  mult_traits<T, U> 
 >::type
 mult(const T& x, const U& y) {return x * y;}
 #endif
 double mult(int i, double d) { return (double)i * d; }
 int test_main(int, char*[])
 {
  BOOST_CHECK(mult(1, 2) == 2);
  BOOST_CHECK(mult(1, 3.0) == 3.0);
  return 0;
 }
--- a/enable_if/test/lazy_test.cpp
+++ b/enable_if/test/lazy_test.cpp
@ -0,0 +1,100 @@
 // Boost enable_if library
 // Copyright 2003 (c) The Trustees of Indiana University.
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 // Testing all variations of lazy_enable_if.
 #include <boost/test/minimal.hpp>
 #include <boost/mpl/not.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 using boost::lazy_enable_if;
 using boost::lazy_disable_if;
 using boost::lazy_enable_if_c;
 using boost::lazy_disable_if_c;
 template <class T>
 struct is_int_or_double {
  BOOST_STATIC_CONSTANT(bool, 
    value = (boost::is_same<T, int>::value || 
             boost::is_same<T, double>::value));
 };
 template <class T>
 struct some_traits {
  typedef typename T::does_not_exist type;
 };
 template <>
 struct some_traits<int> {
  typedef bool type;
 };
 template <>
 struct some_traits<double> {
  typedef bool type;
 };
 template <class T>
 struct make_bool {
  typedef bool type;
 };
 template <>
 struct make_bool<int> {};
 template <>
 struct make_bool<double> {};
 namespace A {
  template<class T>
  typename lazy_enable_if<is_int_or_double<T>, some_traits<T> >::type
  foo(T t) { return true; }
  template<class T>
  typename lazy_enable_if_c<is_int_or_double<T>::value, some_traits<T> >::type
  foo2(T t) { return true; }
 }
 namespace B {
  template<class T>
  typename lazy_disable_if<is_int_or_double<T>, make_bool<T> >::type
  foo(T t) { return false; }
  template<class T>
  typename lazy_disable_if_c<is_int_or_double<T>::value, make_bool<T> >::type
  foo2(T t) { return false; }
 }
 int test_main(int, char*[])
 {
  using namespace A;
  using namespace B;
  BOOST_CHECK(foo(1));
  BOOST_CHECK(foo(1.0));
  BOOST_CHECK(!foo("1"));  
  BOOST_CHECK(!foo(static_cast<void*>(0)));  
  BOOST_CHECK(foo2(1));
  BOOST_CHECK(foo2(1.0));
  BOOST_CHECK(!foo2("1"));  
  BOOST_CHECK(!foo2(static_cast<void*>(0)));  
  return 0;
 }
--- a/enable_if/test/member_templates.cpp
+++ b/enable_if/test/member_templates.cpp
@ -0,0 +1,43 @@
 // Boost enable_if library
 // Copyright 2003 (c) The Trustees of Indiana University.
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 #include <boost/test/minimal.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 using boost::enable_if;
 using boost::disable_if;
 using boost::is_arithmetic;
 struct container {
  template <class T>
  typename enable_if<is_arithmetic<T>, bool>::type
  arithmetic_object(const T&, const int* /* disambiguate */ = 0) {return true;}
  template <class T>
  typename disable_if<is_arithmetic<T>, bool>::type
  arithmetic_object(const T&) {return false;}
 };
 int test_main(int, char*[])
 {
  BOOST_CHECK(container().arithmetic_object(1));
  BOOST_CHECK(container().arithmetic_object(1.0));
  BOOST_CHECK(!container().arithmetic_object("1"));  
  BOOST_CHECK(!container().arithmetic_object(static_cast<void*>(0)));  
  return 0;
 }
--- a/enable_if/test/namespace_disambiguation.cpp
+++ b/enable_if/test/namespace_disambiguation.cpp
@ -0,0 +1,47 @@
 // Boost enable_if library
 // Copyright 2003 (c) The Trustees of Indiana University.
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 #include <boost/test/minimal.hpp>
 #include <boost/mpl/not.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 using boost::enable_if;
 using boost::mpl::not_;
 using boost::is_arithmetic;
 namespace A {
  template<class T>
  typename enable_if<is_arithmetic<T>, bool>::type
  arithmetic_object(T t) { return true; }
 }
 namespace B {
  template<class T>
  typename enable_if<not_<is_arithmetic<T> >, bool>::type
  arithmetic_object(T t) { return false; }
 }
 int test_main(int, char*[])
 {
  using namespace A;
  using namespace B;
  BOOST_CHECK(arithmetic_object(1));
  BOOST_CHECK(arithmetic_object(1.0));
  BOOST_CHECK(!arithmetic_object("1"));  
  BOOST_CHECK(!arithmetic_object(static_cast<void*>(0)));  
  return 0;
 }
--- a/enable_if/test/no_disambiguation.cpp
+++ b/enable_if/test/no_disambiguation.cpp
@ -0,0 +1,43 @@
 // Boost enable_if library
 // Copyright 2003 (c) The Trustees of Indiana University.
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 #include <boost/test/minimal.hpp>
 #include <boost/mpl/not.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 using boost::mpl::not_;
 using boost::enable_if;
 using boost::is_arithmetic;
 template<class T>
 typename enable_if<is_arithmetic<T>, bool>::type
 arithmetic_object(T t) { return true; }
 template<class T>
 typename enable_if<not_<is_arithmetic<T> >, bool>::type
 arithmetic_object(T t) { return false; }
 int test_main(int, char*[])
 {
  BOOST_CHECK(arithmetic_object(1));
  BOOST_CHECK(arithmetic_object(1.0));
  BOOST_CHECK(!arithmetic_object("1"));  
  BOOST_CHECK(!arithmetic_object(static_cast<void*>(0)));  
  return 0;
 }
--- a/enable_if/test/partial_specializations.cpp
+++ b/enable_if/test/partial_specializations.cpp
@ -0,0 +1,67 @@
 // Boost enable_if library
 // Copyright 2003 (c) The Trustees of Indiana University.
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 #include <boost/test/minimal.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 using boost::enable_if_c;
 using boost::disable_if_c;
 using boost::enable_if;
 using boost::disable_if;
 using boost::is_arithmetic;
 template <class T, class Enable = void>
 struct tester;
 template <class T>
 struct tester<T, typename enable_if_c<is_arithmetic<T>::value>::type> {
  BOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class T>
 struct tester<T, typename disable_if_c<is_arithmetic<T>::value>::type> {
  BOOST_STATIC_CONSTANT(bool, value = false);
 };
 template <class T, class Enable = void>
 struct tester2;
 template <class T>
 struct tester2<T, typename enable_if<is_arithmetic<T> >::type> {
  BOOST_STATIC_CONSTANT(bool, value = true);
 };
 template <class T>
 struct tester2<T, typename disable_if<is_arithmetic<T> >::type> {
  BOOST_STATIC_CONSTANT(bool, value = false);
 };
 int test_main(int, char*[])
 {
  BOOST_CHECK(tester<int>::value);
  BOOST_CHECK(tester<double>::value);
  BOOST_CHECK(!tester<char*>::value);
  BOOST_CHECK(!tester<void*>::value);
  BOOST_CHECK(tester2<int>::value);
  BOOST_CHECK(tester2<double>::value);
  BOOST_CHECK(!tester2<char*>::value);
  BOOST_CHECK(!tester2<void*>::value);
  return 0;
 }
--- a/filter_iterator.htm
+++ b/filter_iterator.htm
@ -1,273 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Filter 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">
 <h1>Filter Iterator Adaptor</h1>
 Defined in header
 <a href="../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
 <p>
 The filter iterator adaptor creates a view of an iterator range in
 which some elements of the range are skipped over. A <a
 href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>
 function object controls which elements are skipped. When the
 predicate is applied to an element, if it returns <tt>true</tt> then
 the element is retained and if it returns <tt>false</tt> then the
 element is skipped over.
 <h2>Synopsis</h2>
 <pre>
 namespace boost {
  template &lt;class Predicate, class BaseIterator, ...&gt;
  class filter_iterator_generator;
  template &lt;class Predicate, class BaseIterator&gt;
  typename filter_iterator_generator&lt;Predicate, BaseIterator&gt;::type
  make_filter_iterator(BaseIterator first, BaseIterator last, const Predicate& p = Predicate());
 }
 </pre>
 <hr>
 <h2><a name="filter_iterator_generator">The Filter Iterator Type
 Generator</a></h2>
 The class <tt>filter_iterator_generator</tt> is a helper class whose
 purpose is to construct a filter iterator type.  The template
 parameters for this class are the <tt>Predicate</tt> function object
 type and the <tt>BaseIterator</tt> type that is being wrapped.  In
 most cases the associated types for the wrapped iterator can be
 deduced from <tt>std::iterator_traits</tt>, but in some situations the
 user may want to override these types, so there are also template
 parameters for each of the iterator's associated types.
 <pre>
 template &lt;class Predicate, class BaseIterator,
          class Value, class Reference, class Pointer, class Category, class Distance>
 class filter_iterator_generator
 {
 public:
  typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt;</tt> type; // the resulting filter iterator type 
 }
 </pre>
 <h3>Example</h3>
 The following example uses filter iterator to print out all the
 positive integers in an array. 
 <pre>
 struct is_positive_number {
  bool operator()(int x) { return 0 &lt; x; }
 };
 int main() {
  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
  const int N = sizeof(numbers)/sizeof(int);
  typedef boost::filter_iterator_generator&lt;is_positive_number, int*, int&gt;::type FilterIter;
  is_positive_number predicate;
  FilterIter::policies_type policies(predicate, numbers + N);
  FilterIter filter_iter_first(numbers, policies);
  FilterIter filter_iter_last(numbers + N, policies);
  std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator&lt;int&gt;(std::cout, " "));
  std::cout &lt;&lt; std::endl;
  return 0;
 }
 </pre>
 The output is:
 <pre>
 4 5 8
 </pre>
 <h3>Template Parameters</h3>
 <Table border>
 <TR>
 <TH>Parameter</TH><TH>Description</TH>
 </TR>
 <TR>
 <TD><a href="http://www.sgi.com/tech/stl/Predicate.html"><tt>Predicate</tt></a></TD>
 <TD>The function object that determines which elements are retained and which elements are skipped.
 </TR>
 <TR>
 <TD><tt>BaseIterator</tt></TD>
 <TD>The iterator type being wrapped. This type must at least be a model
 of the <a href="http://www.sgi.com/tech/stl/InputIterator">InputIterator</a> concept.</TD>
 </TR>
 <TR>
 <TD><tt>Value</tt></TD>
 <TD>The <tt>value_type</tt> of the resulting iterator,
 unless const. If const, a conforming compiler strips constness for the
 <tt>value_type</tt>. Typically the default for this parameter is the
 appropriate type<a href="#1">[1]</a>.<br> <b>Default:</b>
 <tt>std::iterator_traits&lt;BaseIterator&gt;::value_type</TD>
 </TR>
 <TR>
 <TD><tt>Reference</tt></TD>
 <TD>The <tt>reference</tt> type of the resulting iterator, and in
 particular, the result type of <tt>operator*()</tt>. Typically the default for
 this parameter is the appropriate type.<br> <b>Default:</b> If
 <tt>Value</tt> is supplied, <tt>Value&amp;</tt> is used. Otherwise
 <tt>std::iterator_traits&lt;BaseIterator&gt;::reference</tt> is
 used.</TD>
 </TR>
 <TR>
 <TD><tt>Pointer</tt></TD>
 <TD>The <tt>pointer</tt> type of the resulting iterator, and in
 particular, the result type of <tt>operator->()</tt>. 
 Typically the default for
 this parameter is the appropriate type.<br>
 <b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
 otherwise <tt>std::iterator_traits&lt;BaseIterator&gt;::pointer</tt>.</TD>
 </TR>
 <TR>
 <TD><tt>Category</tt></TD>
 <TD>The <tt>iterator_category</tt> type for the resulting iterator.
 Typically the
 default for this parameter is the appropriate type. If you override
 this parameter, do not use <tt>bidirectional_iterator_tag</tt>
 because filter iterators can not go in reverse.<br>
 <b>Default:</b> <tt>std::iterator_traits&lt;BaseIterator&gt;::iterator_category</tt></TD>
 </TR>
 <TR>
 <TD><tt>Distance</tt></TD>
 <TD>The <tt>difference_type</tt> for the resulting iterator. Typically the default for
 this parameter is the appropriate type.<br>
 <b>Default:</b> <tt>std::iterator_traits&lt;BaseIterator&gt;::difference_type</TD>
 </TR>
 </table>
 <h3>Model of</h3>
 The filter iterator adaptor (the type
 <tt>filter_iterator_generator<...>::type</tt>) may be a model of <a
 href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a> or <a
 href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>
 depending on the adapted iterator type.
 <h3>Members</h3>
 The filter iterator type implements all of the member functions and
 operators required of the <a
 href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>
 concept.  In addition it has the following constructor:
 <pre>filter_iterator_generator::type(const BaseIterator& it, const Policies& p = Policies())</pre>
 <p>
 The policies type has only one public function, which is its constructor:
 <pre>filter_iterator_generator::policies_type(const Predicate& p, const BaseIterator& end)</pre>
 <p>
 <hr>
 <p>
 <h2><a name="make_filter_iterator">The Make Filter Iterator Function</a></h2>
 <pre>
 template &lt;class Predicate, class BaseIterator&gt;
 typename filter_generator&lt;Predicate, BaseIterator&gt;::type
 make_filter_iterator(BaseIterator first, BaseIterator last, const Predicate& p = Predicate())
 </pre>
 This function provides a convenient way to create filter iterators.
 <h3>Example</h3>
 In this example we print out all numbers in the array that are
 greater than negative two.
 <pre>
 int main()
 {
  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
  const int N = sizeof(numbers)/sizeof(int);
  std::copy(boost::make_filter_iterator(numbers, numbers + N, 
 					std::bind2nd(std::greater<int>(), -2)),
 	    boost::make_filter_iterator(numbers + N, numbers + N, 
 					std::bind2nd(std::greater<int>(), -2)),
 	    std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;
 }
 </pre>
 The output is:
 <pre>
 0 -1 4 5 8 
 </pre>
 <p>
 In the next example we print the positive numbers using the
 <tt>make_filter_iterator()</tt> function.
 <pre>
 struct is_positive_number {
  bool operator()(int x) { return 0 &lt; x; }
 };
 int main()
 {
  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
  const int N = sizeof(numbers)/sizeof(int);
  std::copy(boost::make_filter_iterator&lt;is_positive_number&gt;(numbers, numbers + N),
 	    boost::make_filter_iterator&lt;is_positive_number&gt;(numbers + N, numbers + N),
 	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
  std::cout &lt;&lt; std::endl;
  return 0;
 }
 </pre>
 The output is:
 <pre>
 4 5 8
 </pre>
 <h3>Notes</h3>
 <a name="1">[1]</a> If the compiler does not support partial
 specialization and the wrapped iterator type is a builtin pointer then
 the <tt>Value</tt> type must be explicitly specified (don't use the
 default).
 <hr>
 <p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->09 Mar 2001<!--webbot bot="Timestamp" endspan i-checksum="14894" --></p>
 <p><EFBFBD> Copyright Jeremy Siek 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>
 </body>
 </html>
--- a/filter_iterator_example.cpp
+++ b/filter_iterator_example.cpp
@ -1,61 +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_adaptors.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);
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
  // Assume there won't be proper iterator traits for pointers. This
  // is just a wrapper for int* which has the right traits.
  typedef boost::iterator_adaptor<int*, boost::default_iterator_policies, int> base_iterator;
 #else
  typedef int* base_iterator;
 #endif
  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_generator
  typedef boost::filter_iterator_generator<is_positive_number, base_iterator, int>::type
    FilterIter;
  is_positive_number predicate;
  FilterIter::policies_type policies(predicate, numbers + N);
  FilterIter filter_iter_first(numbers, policies);
  FilterIter filter_iter_last(numbers + N, policies);
  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(numbers, numbers + N, 
                                        std::bind2nd(std::greater<int>(), -2)),
            boost::make_filter_iterator(numbers + N, numbers + N, 
                                        std::bind2nd(std::greater<int>(), -2)),
            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,41 +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/function_output_iterator.htm
+++ b/function_output_iterator.htm
@ -1,169 +0,0 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <html>
 <head>
    <meta name="generator" content="HTML Tidy, see www.w3.org">
    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
    <meta name="ProgId" content="FrontPage.Editor.Document">
    <title>Function Output 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"> 
    <h1>Function Output Iterator Adaptor</h1>
    Defined in header <a href=
    "../../boost/function_output_iterator.hpp">boost/function_output_iterator.hpp</a> 
    <p>The function output iterator adaptor makes it easier to create
    custom output iterators. The adaptor takes a <a
    href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
    Function</a> and creates a model of <a
    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
    Iterator</a>. Each item assigned to the output iterator is passed
    as an argument to the unary function.  The motivation for this
    iterator is that creating a C++ Standard conforming output
    iterator is non-trivial, particularly because the proper
    implementation usually requires a proxy object. On the other hand,
    creating a function (or function object) is much simpler.
    <h2>Synopsis</h2>
    <blockquote>
 <pre>
 namespace boost {
  template &lt;class UnaryFunction&gt;
  class function_output_iterator;
  template &lt;class UnaryFunction&gt;
  function_output_iterator&lt;UnaryFunction&gt;
  make_function_output_iterator(const UnaryFunction&amp; f = UnaryFunction())
 }
 </pre>
    </blockquote>
    <h3>Example</h3>
    In this example we create an output iterator that appends
    each item onto the end of a string, using the <tt>string_appender</tt>
    function. 
    <blockquote>
 <pre>
 #include &lt;iostream&gt;
 #include &lt;string&gt;
 #include &lt;vector&gt;
 #include &lt;boost/function_output_iterator.hpp&gt;
 struct string_appender {
  string_appender(std::string&amp; s) : m_str(s) { }
  void operator()(const std::string&amp; x) const {
    m_str += x;
  }
  std::string&amp; m_str;
 };
 int main(int, char*[])
 {
  std::vector&lt;std::string&gt; 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 &lt;&lt; s &lt;&lt; std::endl;
  return 0;
 }
 </pre>
    </blockquote>
    <hr>
    <h2><a name="function_output_iterator">The Function Output Iterator Class</a></h2>
    <blockquote>
 <pre>
 template &lt;class UnaryFunction&gt;
 class function_output_iterator;
 </pre>
    </blockquote>
    The <tt>function_output_iterator</tt> class creates an <a
    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
    Iterator</a> out of a
    <a href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
    Function</a>. Each item assigned to the output iterator is passed
    as an argument to the unary function.
    <h3>Template Parameters</h3>
    <table border>
      <tr>
        <th>Parameter
        <th>Description
      <tr>
        <td><tt>UnaryFunction</tt> 
        <td>The function type being wrapped. The return type of the
        function is not used, so it can be <tt>void</tt>.  The
        function must be a model of <a
        href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
        Function</a>.</td>
    </table>
    <h3>Concept Model</h3>
    The function output iterator class is a model of <a
    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
    Iterator</a>.
    <h2>Members</h3>
    The function output iterator implements the member functions
    and operators required of the <a
    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
    Iterator</a> concept. In addition it has the following constructor:
 <pre>
 explicit function_output_iterator(const UnaryFunction& f = UnaryFunction())
 </pre>
   <br>    
    <br>
    <hr>
    <h2><a name="make_function_output_iterator">The Function Output Iterator Object
    Generator</a></h2>
    The <tt>make_function_output_iterator()</tt> function provides a
    more convenient way to create function output iterator objects. The
    function saves the user the trouble of explicitly writing out the
    iterator types. If the default argument is used, the function
    type must be provided as an explicit template argument.
    <blockquote>
 <pre>
 template &lt;class UnaryFunction&gt;
 function_output_iterator&lt;UnaryFunction&gt;
 make_function_output_iterator(const UnaryFunction&amp; f = UnaryFunction())
 </pre>
    </blockquote>
    <hr>
    <p>&copy; Copyright Jeremy Siek 2001. 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.
 </body>
 </html>
--- a/generator_iterator.htm
+++ b/generator_iterator.htm
@ -1,33 +1,37 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-<title>Generator Iterator Adaptor Documentation</title>
+  <meta http-equiv="Content-Language" content="en-us">
  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
  <title>Generator Iterator Adaptor Documentation</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
-        
+  <img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle"
-<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86"> 
+  width="277" height="86">
-<h1>Generator Iterator Adaptor</h1>
+  <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.
-<h2>Synopsis</h2>
+  <p>Defined in header <a href=
  "../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>
-<blockquote>
+  <p>The generator iterator adaptor makes it easier to create custom input
-<pre>
+  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>
+  <p>The class generator_iterator_generator is a helper class whose purpose
-
+  is to construct a generator iterator type. The template parameter for this
-The class generator_iterator_generator is a helper class whose purpose
+  class is the Generator function object type that is being wrapped. The
-is to construct a generator iterator type. The template parameter for
+  generator iterator adaptor only holds a reference (or pointer) to the
-this class is the Generator function object type that is being
+  function object, therefore the function object must outlive the generator
-wrapped.  The generator iterator adaptor only holds a reference (or
+  iterator adaptor constructed from it.</p>
-pointer) to the function object, therefore the function object must
+  <pre>
-outlive the generator iterator adaptor constructed from it.
+template &lt;class Generator&gt;
 <pre>
 template &lt;class Generator>
 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>
+      <th>Description</th>
-<tr>
+    </tr>
 <th>Parameter</th>
 <th>Description</th>
 </tr>
-<tr>
+    <tr>
-<td><tt><a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt> 
+      <td><tt><a href=
-<td>The generator (0-ary function object) type being
+      "http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>
 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>
-<h3>Concept Model</h3>
+      <td>The generator (0-ary function object) type being wrapped. The
-The generator iterator class is a model of
+      return type of the function must be defined as
-<a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.
+      <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>
+  <h3>Concept Model</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.
-<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>
+  <h3>Members</h3>
 <h2><a name="make_generator_iterator">The Generator Iterator Object Generator</a></h2>
-The <tt>make_generator_iterator()</tt> function provides a
+  <p>The generator iterator implements the member functions and operators
-convenient way to create generator iterator objects. The function
+  required of the <a href=
-saves the user the trouble of explicitly writing out the iterator
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
-types.
+  concept.<br></p>
  <hr>
-<blockquote>
+  <h2><a name="make_generator_iterator" id="make_generator_iterator">The
-<pre>
+  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_function_output_iterator(Generator &amp; gen);
+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>
+  <blockquote>
-
+    <pre>
-The following program shows how <code>generator_iterator</code>
+#include &lt;iostream&gt;
-transforms a generator into an input iterator.
+#include &lt;boost/generator_iterator.hpp&gt;
 <blockquote>
 <pre>
 #include &lt;iostream>
 #include &lt;boost/generator_iterator.hpp>
 class my_generator
 {
@ -140,11 +142,22 @@ int main()
    std::cout &lt;&lt; *it &lt;&lt; std::endl;
 }
 </pre>
-</blockquote>
+  </blockquote>
  <hr>
-<hr>
+  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
  height="31" width="88"></a></p>
-Written by Jens Maurer.
+  <p>Revised 
  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
  <p><i>Copyright &copy; 2001 <a href=
  "http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a></i></p>
  <p><i>Distributed under the Boost Software License, Version 1.0. (See
  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
  copy at <a href=
  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
 </body>
 </html>
--- a/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 from the contained type. It also allows the container to remove the CopyConstuctible
 requirement from the contained type since objects can be directly constructed in-place without need of a copy.<br>
 The only requirement on the container is that it must provide proper storage (that is, correctly aligned and sized).
 Naturally, the container will typically support uninitialized storage to avoid the in-place construction to override
 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& aFactory )
    :
    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
@ -1,52 +1,131 @@
 #ifndef BOOST_ASSERT_HPP_INCLUDED
 #define BOOST_ASSERT_HPP_INCLUDED
 #if _MSC_VER >= 1020
 #pragma once
 #endif
 //
-//  boost/assert.hpp
+//  boost/assert.hpp - BOOST_ASSERT(expr)
 //                     BOOST_ASSERT_MSG(expr, msg)
 //                     BOOST_VERIFY(expr)
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2007 Peter Dimov
 //  Copyright (c) Beman Dawes 2011
 //
-//  Permission to copy, use, modify, sell and distribute this software
+// Distributed under the Boost Software License, Version 1.0. (See
-//  is granted provided this copyright notice appears in all copies.
+// accompanying file LICENSE_1_0.txt or copy at
-//  This software is provided "as is" without express or implied
+// http://www.boost.org/LICENSE_1_0.txt)
-//  warranty, and with no claim as to its suitability for any purpose.
+//
 //  Note: There are no include guards. This is intentional.
 //
 //  See http://www.boost.org/libs/utility/assert.html for documentation.
 //
 //
-//  When BOOST_DEBUG is not defined, it defaults to 0 (off)
+// Stop inspect complaining about use of 'assert':
 //  for compatibility with programs that do not expect asserts
 //  in the smart pointer class templates.
 //
-//  This default may be changed after an initial transition period.
+// boostinspect:naassert_macro
 //
-#ifndef BOOST_DEBUG
+//--------------------------------------------------------------------------------------//
-#define BOOST_DEBUG 0
+//                                     BOOST_ASSERT                                     //
-#endif
+//--------------------------------------------------------------------------------------//
-#if BOOST_DEBUG
+#undef BOOST_ASSERT
-#include <assert.h>
+#if defined(BOOST_DISABLE_ASSERTS)
-#ifndef BOOST_ASSERT
+# define BOOST_ASSERT(expr) ((void)0)
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER)
 #include <boost/current_function.hpp>
-bool boost_error(char const * expr, char const * func, char const * file, long line);
+namespace boost
 {
  void assertion_failed(char const * expr,
                        char const * function, char const * file, long line); // user defined
 } // namespace boost
-# define BOOST_ASSERT(expr) ((expr) || !boost_error(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__) || (assert(expr), true))
+#define BOOST_ASSERT(expr) ((expr) \
  ? ((void)0) \
  : ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
-#endif // #ifndef BOOST_ASSERT
+#else
 # include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
 # define BOOST_ASSERT(expr) assert(expr)
 #endif
-#else // #if BOOST_DEBUG
+//--------------------------------------------------------------------------------------//
 //                                   BOOST_ASSERT_MSG                                   //
 //--------------------------------------------------------------------------------------//
-#undef BOOST_ASSERT
+# undef BOOST_ASSERT_MSG
 #define BOOST_ASSERT(expr) ((void)0)
-#endif // #if BOOST_DEBUG
+#if defined(BOOST_DISABLE_ASSERTS) || defined(NDEBUG)
-#endif // #ifndef BOOST_ASSERT_HPP_INCLUDED
+  #define BOOST_ASSERT_MSG(expr, msg) ((void)0)
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER)
  #include <boost/current_function.hpp>
  namespace boost
  {
    void assertion_failed_msg(char const * expr, char const * msg,
                              char const * function, char const * file, long line); // user defined
  } // namespace boost
  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
    ? ((void)0) \
    : ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 #else
  #ifndef BOOST_ASSERT_HPP
    #define BOOST_ASSERT_HPP
    #include <cstdlib>
    #include <iostream>
    #include <boost/current_function.hpp>
    //  IDE's like Visual Studio perform better if output goes to std::cout or
    //  some other stream, so allow user to configure output stream:
    #ifndef BOOST_ASSERT_MSG_OSTREAM
    # define BOOST_ASSERT_MSG_OSTREAM std::cerr
    #endif
    namespace boost
    { 
      namespace assertion 
      { 
        namespace detail
        {
          inline void assertion_failed_msg(char const * expr, char const * msg, char const * function,
            char const * file, long line)
          {
            BOOST_ASSERT_MSG_OSTREAM
              << "***** Internal Program Error - assertion (" << expr << ") failed in "
              << function << ":\n"
              << file << '(' << line << "): " << msg << std::endl;
            std::abort();
          }
        } // detail
      } // assertion
    } // detail
  #endif
  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
    ? ((void)0) \
    : ::boost::assertion::detail::assertion_failed_msg(#expr, msg, \
          BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 #endif
 //--------------------------------------------------------------------------------------//
 //                                     BOOST_VERIFY                                     //
 //--------------------------------------------------------------------------------------//
 #undef BOOST_VERIFY
 #if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
 # define BOOST_VERIFY(expr) ((void)(expr))
 #else
 # define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
 #endif
--- a/include/boost/call_traits.hpp
+++ b/include/boost/call_traits.hpp
@ -1,9 +1,10 @@
-//  (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  distribute this software is granted provided this copyright notice appears
+//  Use, modification and distribution are subject to the Boost Software License,
-//  in all copies. This software is provided "as is" without express or implied
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  warranty, and with no claim as to its suitability for any purpose.
+//  http://www.boost.org/LICENSE_1_0.txt).
 //
 //  See http://www.boost.org/libs/utility for most recent version including documentation.
 //  See http://www.boost.org for most recent version including documentation.
 //  See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
 //  for full copyright notices.
--- a/include/boost/checked_delete.hpp
+++ b/include/boost/checked_delete.hpp
@ -1,19 +1,24 @@
 #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
 #define BOOST_CHECKED_DELETE_HPP_INCLUDED
-#if _MSC_VER >= 1020
+// MS compatible compilers support #pragma once
-#pragma once
+
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  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
+//  Distributed under the Boost Software License, Version 1.0. (See
-//  is granted provided this copyright notice appears in all copies.
+//  accompanying file LICENSE_1_0.txt or copy at
-//  This software is provided "as is" without express or implied
+//  http://www.boost.org/LICENSE_1_0.txt)
-//  warranty, and with no claim as to its suitability for any purpose.
+//
 //  See http://www.boost.org/libs/utility/checked_delete.html for documentation.
 //
 namespace boost
@ -21,15 +26,18 @@ namespace boost
 // verify that types are complete for increased safety
-template< typename T > inline void checked_delete(T * x)
+template<class T> inline void checked_delete(T * x)
 {
-    typedef char type_must_be_complete[sizeof(T)];
+    // intentionally complex - simplification causes regressions
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
 }
-template< typename T > inline void checked_array_delete(T * x)
+template<class T> inline void checked_array_delete(T * x)
 {
-    typedef char type_must_be_complete[sizeof(T)];
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete [] x;
 }
@ -38,9 +46,10 @@ template<class T> struct checked_deleter
    typedef void result_type;
    typedef T * argument_type;
-    void operator()(T * x)
+    void operator()(T * x) const
    {
-        checked_delete(x);
+        // boost:: disables ADL
        boost::checked_delete(x);
    }
 };
@ -49,9 +58,9 @@ template<class T> struct checked_array_deleter
    typedef void result_type;
    typedef T * argument_type;
-    void operator()(T * x)
+    void operator()(T * x) const
    {
-        checked_array_delete(x);
+        boost::checked_array_delete(x);
    }
 };
--- a/include/boost/compressed_pair.hpp
+++ b/include/boost/compressed_pair.hpp
@ -1,9 +1,10 @@
-//  (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  distribute this software is granted provided this copyright notice appears
+//  Use, modification and distribution are subject to the Boost Software License,
-//  in all copies. This software is provided "as is" without express or implied
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  warranty, and with no claim as to its suitability for any purpose.
+//  http://www.boost.org/LICENSE_1_0.txt).
 //
 //  See http://www.boost.org/libs/utility for most recent version including documentation.
 //  See http://www.boost.org for most recent version including documentation.
 //  See boost/detail/compressed_pair.hpp and boost/detail/ob_compressed_pair.hpp
 //  for full copyright notices.
--- a/include/boost/current_function.hpp
+++ b/include/boost/current_function.hpp
@ -1,8 +1,10 @@
 #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
 #define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
-#if _MSC_VER >= 1020
+// MS compatible compilers support #pragma once
-#pragma once
+
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
@ -10,10 +12,11 @@
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  Permission to copy, use, modify, sell and distribute this software
+// Distributed under the Boost Software License, Version 1.0. (See
-//  is granted provided this copyright notice appears in all copies.
+// accompanying file LICENSE_1_0.txt or copy at
-//  This software is provided "as is" without express or implied
+// http://www.boost.org/LICENSE_1_0.txt)
-//  warranty, and with no claim as to its suitability for any purpose.
+//
 //  http://www.boost.org/libs/utility/current_function.html
 //
 namespace boost
@ -25,7 +28,11 @@ namespace detail
 inline void current_function_helper()
 {
-#if defined(__GNUC__)
+#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600))
 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
 #elif defined(__DMC__) && (__DMC__ >= 0x810)
 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
@ -33,7 +40,11 @@ inline void current_function_helper()
 # define BOOST_CURRENT_FUNCTION __FUNCSIG__
-#elif defined(__BORLANDC__)
+#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
 # define BOOST_CURRENT_FUNCTION __FUNCTION__
 #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
 # define BOOST_CURRENT_FUNCTION __FUNC__
--- a/include/boost/detail/call_traits.hpp
+++ b/include/boost/detail/call_traits.hpp
@ -1,10 +1,9 @@
 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
+//  Use, modification and distribution are subject to the Boost Software License,
-//  distribute this software is granted provided this copyright notice appears
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  in all copies. This software is provided "as is" without express or implied
+//  http://www.boost.org/LICENSE_1_0.txt).
-//  warranty, and with no claim as to its suitability for any purpose.
+//
-
+//  See http://www.boost.org/libs/utility for most recent version including documentation.
 //  See http://www.boost.org for most recent version including documentation.
 // call_traits: defines typedefs for function usage
 // (see libs/utility/call_traits.htm)
@ -22,13 +21,11 @@
 #ifndef BOOST_CONFIG_HPP
 #include <boost/config.hpp>
 #endif
 #include <cstddef>
-#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
+#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/arithmetic_traits.hpp>
+#include <boost/type_traits/is_pointer.hpp>
-#endif
+#include <boost/detail/workaround.hpp>
 #ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
 #include <boost/type_traits/composite_traits.hpp>
 #endif
 namespace boost{
@ -61,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;
 };
 }
@ -79,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
@ -95,7 +92,7 @@ struct call_traits<T&>
   typedef T& param_type;  // hh removed const
 };
-#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x560)
+#if BOOST_WORKAROUND( __BORLANDC__,  < 0x5A0 )
 // these are illegal specialisations; cv-qualifies applied to
 // references have no effect according to [8.3.2p1],
 // C++ Builder requires them though as it treats cv-qualified
@ -124,8 +121,17 @@ 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
-#ifndef __SUNPRO_CC
+#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
 template <typename T, std::size_t N>
 struct call_traits<T [N]>
 {
--- a/include/boost/detail/compressed_pair.hpp
+++ b/include/boost/detail/compressed_pair.hpp
@ -1,14 +1,16 @@
 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
+//  Use, modification and distribution are subject to the Boost Software License,
-//  distribute this software is granted provided this copyright notice appears
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  in all copies. This software is provided "as is" without express or implied
+//  http://www.boost.org/LICENSE_1_0.txt).
-//  warranty, and with no claim as to its suitability for any purpose.
+//
-
+//  See http://www.boost.org/libs/utility for most recent version including documentation.
 //  See http://www.boost.org for most recent version including documentation.
 // compressed_pair: pair that "compresses" empty members
 // (see libs/utility/compressed_pair.htm)
 //
 // JM changes 25 Jan 2004:
 // For the case where T1 == T2 and both are empty, then first() and second()
 // should return different objects.
 // JM changes 25 Jan 2000:
 // Removed default arguments from compressed_pair_switch to get
 // C++ Builder 4 to accept them
@ -19,16 +21,16 @@
 #define BOOST_DETAIL_COMPRESSED_PAIR_HPP
 #include <algorithm>
 #ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
 #include <boost/type_traits/object_traits.hpp>
 #endif
 #ifndef BOOST_SAME_TRAITS_HPP
 #include <boost/type_traits/same_traits.hpp>
 #endif
 #ifndef BOOST_CALL_TRAITS_HPP
 #include <boost/call_traits.hpp>
 #endif
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/is_empty.hpp>
 #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
 {
@ -134,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;
@ -176,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;
@ -219,8 +221,8 @@ namespace details
   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 3>
-      : private T1,
+      : protected ::boost::remove_cv<T1>::type,
-        private T2
+        protected ::boost::remove_cv<T2>::type
   {
   public:
      typedef T1                                                 first_type;
@ -255,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 -
+   //      Originally this did not store an instance of T2 at all
-   //      but reuses T1 base class for both first() and second().
+   //      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;
@ -273,20 +278,21 @@ namespace details
      compressed_pair_imp() {}
-      compressed_pair_imp(first_param_type x, second_param_type)
+      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_type(x) {}
+         : first_type(x), m_second(y) {}
      compressed_pair_imp(first_param_type x)
-         : first_type(x) {}
+         : first_type(x), m_second(x) {}
      first_reference       first()       {return *this;}
      first_const_reference first() const {return *this;}
-      second_reference       second()       {return *this;}
+      second_reference       second()       {return m_second;}
-      second_const_reference second() const {return *this;}
+      second_const_reference second() const {return m_second;}
      void swap(::boost::compressed_pair<T1,T2>&) {}
   private:
      T2 m_second;
   };
   // 5    T1 == T2 and are not empty:   //JM
@ -429,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/detail/ob_call_traits.hpp
+++ b/include/boost/detail/ob_call_traits.hpp
@ -1,10 +1,9 @@
 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
+//  Use, modification and distribution are subject to the Boost Software License,
-//  distribute this software is granted provided this copyright notice appears
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  in all copies. This software is provided "as is" without express or implied
+//  http://www.boost.org/LICENSE_1_0.txt).
-//  warranty, and with no claim as to its suitability for any purpose.
+//
-
+//  See http://www.boost.org/libs/utility for most recent version including documentation.
 //  See http://www.boost.org for most recent version including documentation.
 //
 //  Crippled version for crippled compilers:
 //  see libs/utility/call_traits.htm
--- a/include/boost/detail/ob_compressed_pair.hpp
+++ b/include/boost/detail/ob_compressed_pair.hpp
@ -1,10 +1,9 @@
 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Permission to copy, use, modify, sell and
+//  Use, modification and distribution are subject to the Boost Software License,
-//  distribute this software is granted provided this copyright notice appears
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  in all copies. This software is provided "as is" without express or implied
+//  http://www.boost.org/LICENSE_1_0.txt).
-//  warranty, and with no claim as to its suitability for any purpose.
+//
-
+//  See http://www.boost.org/libs/utility for most recent version including documentation.
 //  See http://www.boost.org for most recent version including documentation.
 //  see libs/utility/compressed_pair.hpp
 //
 /* Release notes:
@ -293,22 +292,24 @@ public:
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_4() : T1() {}
-            compressed_pair_4(first_param_type x, second_param_type) : T1(x) {}
+            compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {}
   // only one single argument constructor since T1 == T2
-   explicit compressed_pair_4(first_param_type x) : T1(x) {}
+   explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {}
   compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)
-      : T1(x.first()){}
+      : T1(x.first()), m_second(x.second()) {}
   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }
-   second_reference       second()       { return *this; }
+   second_reference       second()       { return m_second; }
-   second_const_reference second() const { return *this; }
+   second_const_reference second() const { return m_second; }
   void swap(compressed_pair_4& y)
   {
      // no need to swap empty base classes:
   }
 private:
   T2 m_second;
 };
 // T1 == T2, not empty
--- a/include/boost/exception.hpp
+++ b/include/boost/exception.hpp
@ -0,0 +1,11 @@
 //Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
 //Distributed under the Boost Software License, Version 1.0. (See accompanying
 //file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #ifndef UUID_1D94A7C6054E11DB9804B622A1EF5492
 #define UUID_1D94A7C6054E11DB9804B622A1EF5492
 #error The header <boost/exception.hpp> has been deprecated. Please #include <boost/exception/all.hpp> instead.
 #endif
--- a/include/boost/generator_iterator.hpp
+++ b/include/boost/generator_iterator.hpp
@ -1,68 +1,75 @@
-// (C) Copyright Jens Maurer 2001. Permission to copy, use,
+// (C) Copyright Jens Maurer 2001.
-// modify, sell and distribute this software is granted provided this
+// Distributed under the Boost Software License, Version 1.0. (See
-// copyright notice appears in all copies. This software is provided
+// accompanying file LICENSE_1_0.txt or copy at
-// "as is" without express or implied warranty, and with no claim as
+// http://www.boost.org/LICENSE_1_0.txt)
 // to its suitability for any purpose.
 //
 // Revision History:
 // 15 Nov 2001   Jens Maurer
 //      created.
 //  See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation.
 #ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
 #define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
-#include <boost/iterator_adaptors.hpp>
+#include <boost/iterator/iterator_facade.hpp>
 #include <boost/ref.hpp>
 namespace boost {
 template<class Generator>
-class generator_iterator_policies
+class generator_iterator
  : public iterator_facade<
        generator_iterator<Generator>
      , typename Generator::result_type
      , single_pass_traversal_tag
      , typename Generator::result_type const&
    >
 {
-public:
+    typedef iterator_facade<
-    generator_iterator_policies() { }
+        generator_iterator<Generator>
      , typename Generator::result_type
      , single_pass_traversal_tag
      , typename Generator::result_type const&
    > super_t;
 public:
    generator_iterator() {}
    generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}
-    template<class Base>
+    void increment()
-    void initialize(Base& base) {
+    {
-      m_value = (*base)();
+        m_value = (*m_g)();
    }
    // The Iter template argument is necessary for compatibility with a MWCW
    // bug workaround
    template <class IteratorAdaptor>
    void increment(IteratorAdaptor& iter) {
      m_value = (*iter.base())();
    }
    template <class IteratorAdaptor>
    const typename Generator::result_type&
-    dereference(const IteratorAdaptor&) const
+    dereference() const
-        { return m_value; }
+    {
        return m_value;
    }
-    template <class IteratorAdaptor1, class IteratorAdaptor2>
+    bool equal(generator_iterator const& y) const
-    bool equal(const IteratorAdaptor1& x, const IteratorAdaptor2& y) const
+    {
-        { return x.base() == y.base() &&
+        return this->m_g == y.m_g && this->m_value == y.m_value;
-            x.policies().m_value == y.policies().m_value; }
+    }
-private:
+ private:
-  typename Generator::result_type m_value;
+    Generator* m_g;
    typename Generator::result_type m_value;
 };
 template<class Generator>
 struct generator_iterator_generator
 {
-  typedef iterator_adaptor<Generator*, generator_iterator_policies<Generator>,
+  typedef generator_iterator<Generator> type;
    typename Generator::result_type, const typename Generator::result_type&,
    const typename Generator::result_type*, std::input_iterator_tag,
    long>       type;
 };
 template <class Generator>
-inline typename generator_iterator_generator<Generator>::type
+inline generator_iterator<Generator>
 make_generator_iterator(Generator & gen)
 {
-  typedef typename generator_iterator_generator<Generator>::type result_t;
+  typedef generator_iterator<Generator> result_t;
  return result_t(&gen);
 }
--- a/include/boost/next_prior.hpp
+++ b/include/boost/next_prior.hpp
@ -0,0 +1,51 @@
 //  Boost next_prior.hpp header file  ---------------------------------------//
 //  (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.
 //  Revision History
 //  13 Dec 2003  Added next(x, n) and prior(x, n) (Daniel Walker)
 #ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
 #define BOOST_NEXT_PRIOR_HPP_INCLUDED
 #include <iterator>
 namespace boost {
 //  Helper functions for classes like bidirectional iterators not supporting
 //  operator+ and operator-
 //
 //  Usage:
 //    const std::list<T>::iterator p = get_some_iterator();
 //    const std::list<T>::iterator prev = boost::prior(p);
 //    const std::list<T>::iterator next = boost::next(prev, 2);
 //  Contributed by Dave Abrahams
 template <class T>
 inline T next(T x) { return ++x; }
 template <class T, class Distance>
 inline T next(T x, Distance n)
 {
    std::advance(x, n);
    return x;
 }
 template <class T>
 inline T prior(T x) { return --x; }
 template <class T, class Distance>
 inline T prior(T x, Distance n)
 {
    std::advance(x, -n);
    return x;
 }
 } // namespace boost
 #endif  // BOOST_NEXT_PRIOR_HPP_INCLUDED
--- a/include/boost/noncopyable.hpp
+++ b/include/boost/noncopyable.hpp
@ -0,0 +1,36 @@
 //  Boost noncopyable.hpp header file  --------------------------------------//
 //  (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.
 #ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
 #define BOOST_NONCOPYABLE_HPP_INCLUDED
 namespace boost {
 //  Private copy constructor and copy assignment ensure classes derived from
 //  class noncopyable cannot be copied.
 //  Contributed by Dave Abrahams
 namespace noncopyable_  // protection from unintended ADL
 {
  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
 #endif  // BOOST_NONCOPYABLE_HPP_INCLUDED
--- a/include/boost/operators.hpp
+++ b/include/boost/operators.hpp
@ -1,14 +1,23 @@
 //  Boost operators.hpp header file  ----------------------------------------//
-//  (C) Copyright David Abrahams, Jeremy Siek, and Daryle Walker 1999-2001.
+//  (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
-//  Permission to copy, use, modify, sell and distribute this software is
+//  Distributed under the Boost Software License, Version 1.0. (See
-//  granted provided this copyright notice appears in all copies.  This
+//  accompanying file LICENSE_1_0.txt or copy at
-//  software is provided "as is" without express or implied warranty, and
+//  http://www.boost.org/LICENSE_1_0.txt)
 //  with no claim as to its suitability for any purpose.
-//  See http://www.boost.org for most recent version including documentation.
+//  See http://www.boost.org/libs/utility/operators.htm for documentation.
 //  Revision History
 //  16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
 //            (Matthew Bradbury, fixes #4432)
 //  07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
 //  03 Apr 08 Make sure "convertible to bool" is sufficient
 //            for T::operator<, etc. (Daniel Frey)
 //  24 May 07 Changed empty_base to depend on T, see
 //            http://svn.boost.org/trac/boost/ticket/979
 //  21 Oct 02 Modified implementation of operators to allow compilers with a
 //            correct named return value optimization (NRVO) to produce optimal
 //            code.  (Daniel Frey)
 //  02 Dec 01 Bug fixed in random_access_iteratable.  (Helmut Zeisel)
 //  28 Sep 01 Factored out iterator operator groups.  (Daryle Walker)
 //  27 Aug 01 'left' form for non commutative operators added;
@ -75,27 +84,28 @@
 #include <boost/config.hpp>
 #include <boost/iterator.hpp>
 #include <boost/detail/workaround.hpp>
 #if defined(__sgi) && !defined(__GNUC__)
-#pragma set woff 1234
+#   pragma set woff 1234
 #endif
-#if defined(BOOST_MSVC)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1600)
 #   pragma warning( disable : 4284 ) // complaint about return type of 
 #endif                               // operator-> not begin a UDT
 namespace boost {
 namespace detail {
 template <typename T> class empty_base {
 // Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
 class empty_base {
  bool dummy; 
 };
 #else
 class empty_base {};
 #endif
 };
 } // namespace detail
 } // namespace boost
@ -116,184 +126,169 @@ 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 !static_cast<bool>(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 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 !(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 !static_cast<bool>(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>(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 U& y, const T& x) { return !static_cast<bool>(x == y); }
-     friend bool operator!=(const T& y, const U& x) { return !(y == x); }
+     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); }
 };
-template <class T, class U, class B = ::boost::detail::empty_base>
+// A macro which produces "name_2left" from "name".
-struct multipliable2 : B
+#define BOOST_OPERATOR2_LEFT(name) name##2##_##left
-{
+
-     friend T operator*(T x, const U& y) { return x *= y; }
+//  NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
-     friend T operator*(const U& y, T x) { return x *= y; }
+
 #if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 // This is the optimal implementation for ISO/ANSI C++,
 // but it requires the compiler to implement the NRVO.
 // If the compiler has no NRVO, this is the best symmetric
 // implementation available.
 #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( const T& lhs, const U& rhs )                          \
    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
  friend T operator OP( const U& lhs, const T& rhs )                          \
    { T nrv( rhs ); nrv OP##= lhs; 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; }                              \
 };
-template <class T, class B = ::boost::detail::empty_base>
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-struct multipliable1 : B
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
-{
+struct NAME##2 : B                                                      \
-     friend T operator*(T x, const T& y) { return x *= y; }
+{                                                                       \
  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; }                        \
 };
-template <class T, class U, class B = ::boost::detail::empty_base>
+#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-struct addable2 : B
+
-{
+// For compilers without NRVO the following code is optimal, but not
-     friend T operator+(T x, const U& y) { return x += y; }
+// symmetric!  Note that the implementation of
-     friend T operator+(const U& y, T x) { return x += y; }
+// 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<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; } \
 };
-template <class T, class B = ::boost::detail::empty_base>
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-struct addable1 : B
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
-{
+struct NAME##2 : B                                                      \
-     friend T operator+(T x, const T& y) { return x += y; }
+{                                                                       \
  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
 };                                                                      \
                                                                        \
 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<T> >           \
 struct NAME##1 : B                                                      \
 {                                                                       \
  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
 };
-template <class T, class U, class B = ::boost::detail::empty_base>
+#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 struct subtractable2 : B
 {
     friend T operator-(T x, const U& y) { return x -= y; }
 };
-template <class T, class U, class B = ::boost::detail::empty_base>
+BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
-struct subtractable2_left : B
+BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
-{
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
-  friend T operator-(const U& x, const T& y)
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
-    { T result(x); return result -= y; }
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
-};
+BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
 BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
 BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
-template <class T, class B = ::boost::detail::empty_base>
+#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
-struct subtractable1 : B
+#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
-{
+#undef BOOST_OPERATOR2_LEFT
     friend T operator-(T x, const T& y) { return x -= y; }
 };
 template <class T, class U, class B = ::boost::detail::empty_base>
 struct dividable2 : B
 {
     friend T operator/(T x, const U& y) { return x /= y; }
 };
 template <class T, class U, class B = ::boost::detail::empty_base>
 struct dividable2_left : B
 {
  friend T operator/(const U& x, const T& y)
    { T result(x); return result /= y; }
 };
 template <class T, class B = ::boost::detail::empty_base>
 struct dividable1 : B
 {
     friend T operator/(T x, const T& y) { return x /= y; }
 };
 template <class T, class U, class B = ::boost::detail::empty_base>
 struct modable2 : B
 {
     friend T operator%(T x, const U& y) { return x %= y; }
 };
 template <class T, class U, class B = ::boost::detail::empty_base>
 struct modable2_left : B
 {
  friend T operator%(const U& x, const T& y)
    { T result(x); return result %= y; }
 };
 template <class T, class B = ::boost::detail::empty_base>
 struct modable1 : B
 {
     friend T operator%(T x, const T& y) { return x %= y; }
 };
 template <class T, class U, class B = ::boost::detail::empty_base>
 struct xorable2 : B
 {
     friend T operator^(T x, const U& y) { return x ^= y; }
     friend T operator^(const U& y, T x) { return x ^= y; }
 };
 template <class T, class B = ::boost::detail::empty_base>
 struct xorable1 : B
 {
     friend T operator^(T x, const T& y) { return x ^= y; }
 };
 template <class T, class U, class B = ::boost::detail::empty_base>
 struct andable2 : B
 {
     friend T operator&(T x, const U& y) { return x &= y; }
     friend T operator&(const U& y, T x) { return x &= y; }
 };
 template <class T, class B = ::boost::detail::empty_base>
 struct andable1 : B
 {
     friend T operator&(T x, const T& y) { return x &= y; }
 };
 template <class T, class U, class B = ::boost::detail::empty_base>
 struct orable2 : B
 {
     friend T operator|(T x, const U& y) { return x |= y; }
     friend T operator|(const U& y, T x) { return x |= y; }
 };
 template <class T, class B = ::boost::detail::empty_base>
 struct orable1 : B
 {
     friend T operator|(T x, const T& y) { return x |= y; }
 };
 //  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)
  {
-    incrementable_type tmp(x);
+    incrementable_type nrv(x);
    ++x;
-    return tmp;
+    return nrv;
  }
 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)
  {
-    decrementable_type tmp(x);
+    decrementable_type nrv(x);
    --x;
-    return tmp;
+    return nrv;
  }
 private: // The use of this typedef works around a Borland bug
  typedef T decrementable_type;
@ -301,7 +296,7 @@ private: // The use of this typedef works around a Borland bug
 //  Iterator operator classes (contributed by Jeremy Siek) ------------------//
-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct dereferenceable : B
 {
  P operator->() const
@ -310,7 +305,7 @@ struct dereferenceable : B
  }
 };
-template <class T, class I, class R, class B = ::boost::detail::empty_base>
+template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
 struct indexable : B
 {
  R operator[](I n) const
@ -320,234 +315,250 @@ struct indexable : B
 };
 //  More operator classes (contributed by Daryle Walker) --------------------//
 //  (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
-template <class T, class U, class B = ::boost::detail::empty_base>
+#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-struct left_shiftable2 : B
+
-{
+#define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-     friend T operator<<(T x, const U& y) { return x <<= y; }
+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<T> >                 \
 struct NAME##1 : B                                                            \
 {                                                                             \
  friend T operator OP( const T& lhs, const T& rhs )                          \
    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 };
-template <class T, class B = ::boost::detail::empty_base>
+#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
-struct left_shiftable1 : B
+
-{
+#define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
-     friend T operator<<(T x, const T& y) { return x <<= y; }
+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<T> >                 \
 struct NAME##1 : B                                                            \
 {                                                                             \
  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
 };
-template <class T, class U, class B = ::boost::detail::empty_base>
+#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 struct right_shiftable2 : B
 {
     friend T operator>>(T x, const U& y) { return x >>= y; }
 };
-template <class T, class B = ::boost::detail::empty_base>
+BOOST_BINARY_OPERATOR( left_shiftable, << )
-struct right_shiftable1 : B
+BOOST_BINARY_OPERATOR( right_shiftable, >> )
 {
     friend T operator>>(T x, const T& y) { return x >>= y; }
 };
-template <class T, class U, class B = ::boost::detail::empty_base>
+#undef BOOST_BINARY_OPERATOR
 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
@ -556,43 +567,71 @@ struct euclidian_ring_operators2
    , modable2_left<T, U, B
      > > > > > {};
-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct euclidian_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};
-template <class T, class U, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ordered_euclidian_ring_operators2
    : totally_ordered2<T, U
    , euclidian_ring_operators2<T, U, B
      > > {};
-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct ordered_euclidian_ring_operators1
    : totally_ordered1<T
    , euclidian_ring_operators1<T, B
      > > {};
-      
+
-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct euclidean_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U
    , modable2<T, U
    , modable2_left<T, U, B
      > > > > > {};
 template <class T, class B = ::boost::detail::empty_base<T> >
 struct euclidean_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};
 template <class T, class U, class B = ::boost::detail::empty_base<T> >
 struct ordered_euclidean_ring_operators2
    : totally_ordered2<T, U
    , euclidean_ring_operators2<T, U, B
      > > {};
 template <class T, class B = ::boost::detail::empty_base<T> >
 struct ordered_euclidean_ring_operators1
    : totally_ordered1<T
    , euclidean_ring_operators1<T, B
      > > {};
 template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct input_iteratable
    : equality_comparable1<T
    , incrementable<T
    , dereferenceable<T, P, B
      > > > {};
-template <class T, class B = ::boost::detail::empty_base>
+template <class T, class B = ::boost::detail::empty_base<T> >
 struct output_iteratable
    : incrementable<T, B
      > {};
-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct forward_iteratable
    : input_iteratable<T, P, B
      > {};
-template <class T, class P, class B = ::boost::detail::empty_base>
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
 struct bidirectional_iteratable
    : forward_iteratable<T, P
    , decrementable<T, B
@ -602,7 +641,7 @@ struct bidirectional_iteratable
 //  which is an indirect base class of bidirectional_iterable,
 //  random_access_iteratable must not be derived from totally_ordered1
 //  but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
-template <class T, class P, class D, class R, class B = ::boost::detail::empty_base>
+template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
 struct random_access_iteratable
    : bidirectional_iteratable<T, P
    , less_than_comparable1<T
@ -646,20 +685,20 @@ struct random_access_iteratable
     // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
     // from working, we are forced to use inheritance for that compiler.
-#    define BOOST_IMPORT_TEMPLATE4(template_name)                                          \
+#    define BOOST_IMPORT_TEMPLATE4(template_name)                                             \
-     template <class T, class U, class V, class W, class B = ::boost::detail::empty_base>  \
+     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)                                 \
+#    define BOOST_IMPORT_TEMPLATE3(template_name)                                    \
-     template <class T, class U, class V, class B = ::boost::detail::empty_base>  \
+     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)                              \
+#    define BOOST_IMPORT_TEMPLATE2(template_name)                           \
-     template <class T, class U, class B = ::boost::detail::empty_base>        \
+     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)                              \
+#    define BOOST_IMPORT_TEMPLATE1(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<T, B> {};
 #  endif // BOOST_NO_USING_TEMPLATE
@ -670,7 +709,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
@ -695,7 +734,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)                              \
@ -704,7 +743,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)                              \
@ -713,7 +752,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)                           \
@ -722,7 +761,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)                           \
@ -748,7 +787,7 @@ template<class T> struct is_chained_base {
 # define BOOST_OPERATOR_TEMPLATE(template_name)                    \
 template <class T                                                  \
         ,class U = T                                              \
-         ,class B = ::boost::detail::empty_base                    \
+         ,class B = ::boost::detail::empty_base<T>                 \
         ,class O = typename is_chained_base<U>::value             \
         >                                                         \
 struct template_name : template_name##2<T, U, B> {};               \
@ -784,7 +823,7 @@ BOOST_OPERATOR_TEMPLATE1(template_name##1)
   // In this case we can only assume that template_name<> is equivalent to the
   // more commonly needed template_name1<> form.
 #  define BOOST_OPERATOR_TEMPLATE(template_name)                   \
-   template <class T, class B = ::boost::detail::empty_base>       \
+   template <class T, class B = ::boost::detail::empty_base<T> >   \
   struct template_name : template_name##1<T, B> {};
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@ -831,6 +870,8 @@ BOOST_OPERATOR_TEMPLATE(field_operators)
 BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
 BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
 BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
 BOOST_OPERATOR_TEMPLATE(euclidean_ring_operators)
 BOOST_OPERATOR_TEMPLATE(ordered_euclidean_ring_operators)
 BOOST_OPERATOR_TEMPLATE2(input_iteratable)
 BOOST_OPERATOR_TEMPLATE1(output_iteratable)
 BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
--- a/include/boost/ref.hpp
+++ b/include/boost/ref.hpp
@ -1,24 +1,27 @@
 #ifndef BOOST_REF_HPP_INCLUDED
-# define BOOST_REF_HPP_INCLUDED
+#define BOOST_REF_HPP_INCLUDED
-# if _MSC_VER+0 >= 1020
+// MS compatible compilers support #pragma once
 #  pragma once
 # endif
-# include <boost/config.hpp>
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# include <boost/utility/addressof.hpp>
+# pragma once
 #endif
 #include <boost/config.hpp>
 #include <boost/utility/addressof.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/detail/workaround.hpp>
 //
 //  ref.hpp - ref/cref, useful helper functions
 //
-//  Copyright (C) 1999, 2000 Jaakko J<EFBFBD>rvi (jaakko.jarvi@cs.utu.fi)
+//  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //  Copyright (C) 2001, 2002 Peter Dimov
 //  Copyright (C) 2002 David Abrahams
 //
-//  Permission to copy, use, modify, sell and distribute this software
+// Distributed under the Boost Software License, Version 1.0. (See
-//  is granted provided this copyright notice appears in all copies.
+// accompanying file LICENSE_1_0.txt or copy at
-//  This software is provided "as is" without express or implied
+// http://www.boost.org/LICENSE_1_0.txt)
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/bind/ref.html for documentation.
 //
@ -31,13 +34,13 @@ 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) {}
 #else
-    explicit reference_wrapper(T& t): t_(addressof(t)) {}
+    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
 #endif
@ -52,7 +55,7 @@ private:
    T* t_;
 };
-# if defined(__BORLANDC__) && (__BORLANDC__ <= 0x560)
+# if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
 #  define BOOST_REF_CONST
 # else
 #  define BOOST_REF_CONST const
@ -71,18 +74,11 @@ 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:
    BOOST_STATIC_CONSTANT(bool, value = false); 
 };
 template<typename T>
-class is_reference_wrapper<reference_wrapper<T> >
+class is_reference_wrapper
    : public mpl::false_
 {
 public:
    BOOST_STATIC_CONSTANT(bool, value = true);
 };
 template<typename T>
@ -92,12 +88,30 @@ class unwrap_reference
    typedef T type;
 };
-template<typename T>
+#  define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \
-class unwrap_reference<reference_wrapper<T> >
+template<typename T> \
-{
+class is_reference_wrapper< X > \
- public:
+    : public mpl::true_ \
-    typedef T type;
+{ \
-};
+}; \
 \
 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
@ -144,8 +158,10 @@ class is_reference_wrapper
 public:
    BOOST_STATIC_CONSTANT(
        bool, value = (
-            sizeof(detail::is_reference_wrapper_test(type<T>()))
+             sizeof(detail::is_reference_wrapper_test(type<T>()))
            == sizeof(detail::yes_reference_wrapper_t)));
    typedef ::boost::mpl::bool_<value> type;
 };
 template <typename T>
@ -157,6 +173,17 @@ class unwrap_reference
 # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T> inline typename unwrap_reference<T>::type&
 unwrap_ref(T& t)
 {
    return t;
 }
 template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
 {
    return r.get_pointer();
 }
 } // namespace boost
 #endif // #ifndef BOOST_REF_HPP_INCLUDED
--- a/include/boost/swap.hpp
+++ b/include/boost/swap.hpp
@ -0,0 +1,12 @@
 // Copyright (C) 2007 Joseph Gauterin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #ifndef BOOST_SWAP_HPP
 #define BOOST_SWAP_HPP
 #include "boost/utility/swap.hpp"
 #endif
--- a/include/boost/utility.hpp
+++ b/include/boost/utility.hpp
@ -1,63 +1,20 @@
-//  boost utility.hpp header file  -------------------------------------------//
+//  Boost utility.hpp header file  -------------------------------------------//
-//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
+//  Copyright 1999-2003 Aleksey Gurtovoy.  Use, modification, and distribution are
-//  and distribute this software is granted provided this copyright
+//  subject to the Boost Software License, Version 1.0.  (See accompanying file
-//  notice appears in all copies. This software is provided "as is" without
+//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
 //  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.
+//  See <http://www.boost.org/libs/utility/> for the library's home page.
 //  Classes appear in alphabetical order
 #ifndef BOOST_UTILITY_HPP
 #define BOOST_UTILITY_HPP
 // certain headers are part of the <utility.hpp> interface
 #include <boost/checked_delete.hpp>
 #include <boost/utility/base_from_member.hpp>  
 #include <boost/utility/addressof.hpp>
-
+#include <boost/utility/base_from_member.hpp>
-namespace boost
+#include <boost/utility/binary.hpp>
-{
+#include <boost/utility/enable_if.hpp>
-//  next() and prior() template functions  -----------------------------------//
+#include <boost/checked_delete.hpp>
-
+#include <boost/next_prior.hpp>
-    //  Helper functions for classes like bidirectional iterators not supporting
+#include <boost/noncopyable.hpp>
    //  operator+ and operator-.
    //
    //  Usage:
    //    const std::list<T>::iterator p = get_some_iterator();
    //    const std::list<T>::iterator prev = boost::prior(p);
    //  Contributed by Dave Abrahams
    template <class T>
    inline T next(T x) { return ++x; }
    template <class T>
    inline T prior(T x) { return --x; }
 //  class noncopyable  -------------------------------------------------------//
    //  Private copy constructor and copy assignment ensure classes derived from
    //  class noncopyable cannot be copied.
    //  Contributed by Dave Abrahams
    class noncopyable
    {
    protected:
        noncopyable(){}
        ~noncopyable(){}
    private:  // emphasize the following members are private
        noncopyable( const noncopyable& );
        const noncopyable& operator=( const noncopyable& );
    }; // noncopyable
 } // namespace boost
 #endif  // BOOST_UTILITY_HPP
--- a/include/boost/utility/addressof.hpp
+++ b/include/boost/utility/addressof.hpp
@ -1,31 +1,102 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
-//                    Doug Gregor (gregod@cs.rpi.edu)
+//                    Douglas Gregor (gregod@cs.rpi.edu)
 //                    Peter Dimov
 //
-// Permission to copy, use, sell and distribute this software is granted
+// Copyright (C) 2002, 2008 Peter Dimov
 // 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,
+// Distributed under the Boost Software License, Version 1.0. (See
-// and with no claim as to its suitability for any purpose.
+// accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // For more information, see http://www.boost.org
 #ifndef BOOST_UTILITY_ADDRESSOF_HPP
-#define BOOST_UTILITY_ADDRESSOF_HPP
+# define BOOST_UTILITY_ADDRESSOF_HPP
-namespace boost {
+# include <boost/config.hpp>
 # include <boost/detail/workaround.hpp>
-// Do not make addressof() inline. Breaks MSVC 7. (Peter Dimov)
+namespace boost
 template <typename T> T* addressof(T& v)
 {
-  return reinterpret_cast<T*>(
+
-       &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+namespace detail
 {
 template<class T> struct addr_impl_ref
 {
    T & v_;
    inline addr_impl_ref( T & v ): v_( v ) {}
    inline operator T& () const { return v_; }
 private:
    addr_impl_ref & operator=(const addr_impl_ref &);
 };
 template<class T> struct addressof_impl
 {
    static inline T * f( T & v, long )
    {
        return reinterpret_cast<T*>(
            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
    }
    static inline T * f( T * v, int )
    {
        return v;
    }
 };
 } // namespace detail
 template<class T> T * addressof( T & v )
 {
 #if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) )
    return boost::detail::addressof_impl<T>::f( v, 0 );
 #else
    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
 #endif
 }
 #if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
 namespace detail
 {
 template<class T> struct addressof_addp
 {
    typedef T * type;
 };
 } // namespace detail
 template< class T, std::size_t N >
 typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
 {
    return &t;
 }
 #endif
 // Borland doesn't like casting an array reference to a char reference
 // but these overloads work around the problem.
 #if defined( __BORLANDC__ ) && 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,17 +1,53 @@
 //  boost utility/base_from_member.hpp header file  --------------------------//
-//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
+//  Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and
-//  and distribute this software is granted provided this copyright
+//  distribution are subject to the Boost Software License, Version 1.0.  (See
-//  notice appears in all copies.  This software is provided "as is" without
+//  accompanying file LICENSE_1_0.txt or a copy at
-//  express or implied warranty, and with no claim as to its suitability for
+//  <http://www.boost.org/LICENSE_1_0.txt>.)
 //  any purpose.
-//  See http://www.boost.org for most recent version including documentation.
+//  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
@ -26,34 +62,26 @@ namespace boost
 // Contributed by Daryle Walker
-template < typename MemberType, int UniqueID >
+template < typename MemberType, int UniqueID = 0 >
 class base_from_member
 {
 protected:
    MemberType  member;
-    explicit  base_from_member()
+    base_from_member()
        : member()
        {}
-    template< typename T1 >
+    BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
-    explicit base_from_member( T1 x1 )
+     BOOST_PRIVATE_CTR_DEF, _ )
        : 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 ) 
        {}
 };  // 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/binary.hpp
+++ b/include/boost/utility/binary.hpp
@ -0,0 +1,708 @@
 /*=============================================================================
    Copyright (c) 2005 Matthew Calabrese
    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #ifndef BOOST_UTILITY_BINARY_HPP
 #define BOOST_UTILITY_BINARY_HPP
 /*=============================================================================
    Binary Literal Utility
    ______________________
    The following code works by converting the input bit pattern into a
    Boost.Preprocessor sequence, then converting groupings of 3 bits each into
    the corresponding octal digit, and finally concatenating all of the digits
    together along with a leading zero. This yields a standard octal literal
    with the desired value as specified in bits.
 ==============================================================================*/
 #include <boost/preprocessor/control/deduce_d.hpp>
 #include <boost/preprocessor/facilities/identity.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/seq/cat.hpp>
 #include <boost/preprocessor/seq/transform.hpp>
 #include <boost/preprocessor/arithmetic/mod.hpp>
 #include <boost/preprocessor/seq/size.hpp>
 #include <boost/preprocessor/facilities/empty.hpp>
 #include <boost/preprocessor/control/while.hpp>
 #define BOOST_BINARY( bit_groupings )                                          \
  BOOST_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings ) 
 #define BOOST_BINARY_U( bit_groupings )                                        \
  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, U ) 
 #define BOOST_BINARY_L( bit_groupings )                                        \
  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, L ) 
 #define BOOST_BINARY_UL( bit_groupings )                                       \
  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, UL ) 
 #define BOOST_BINARY_LU( bit_groupings )                                       \
  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LU ) 
 #define BOOST_BINARY_LL( bit_groupings )                                       \
  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LL ) 
 #define BOOST_BINARY_ULL( bit_groupings )                                      \
  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, ULL ) 
 #define BOOST_BINARY_LLU( bit_groupings )                                      \
  BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LLU ) 
 #define BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, suffix )                 \
  BOOST_SUFFIXED_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings, suffix ) 
 #define BOOST_SUFFIXED_BINARY_LITERAL_D( d, bit_groupings, suffix )            \
  BOOST_PP_CAT( BOOST_BINARY_LITERAL_D( d, bit_groupings ), suffix ) 
 #define BOOST_BINARY_LITERAL_D( d, bit_groupings )                             \
  BOOST_PP_SEQ_CAT                                                             \
  ( (0) BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings )  \
  ) 
 #define BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings )  \
  BOOST_PP_SEQ_TRANSFORM                                                       \
  ( BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION                                     \
  , BOOST_PP_NIL                                                               \
  , BOOST_PP_IDENTITY( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE )()\
    ( BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE                                    \
      (                                                                        \
        d                                                                      \
      , BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings )    \
      )                                                                        \
    )                                                                          \
  ) 
 #define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE( bit_sequence )   \
  BOOST_PP_CAT                                                                 \
  ( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 bit_sequence      \
  , END_BIT                                                                    \
  ) 
 #define BOOST_DETAIL_BITS_PER_OCTIT 3
 #define BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE( d, incomplete_nibble_sequence ) \
  BOOST_PP_CAT                                                                 \
  ( BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_                            \
  , BOOST_PP_MOD_D( d                                                          \
                  , BOOST_PP_SEQ_SIZE( incomplete_nibble_sequence )            \
                  , BOOST_DETAIL_BITS_PER_OCTIT                                \
                  )                                                            \
  )                                                                            \
  incomplete_nibble_sequence 
 #define BOOST_DETAIL_FIXED_COMPL( bit )                                        \
  BOOST_PP_CAT( BOOST_DETAIL_FIXED_COMPL_, bit )
 #define BOOST_DETAIL_FIXED_COMPL_0 1 
 #define BOOST_DETAIL_FIXED_COMPL_1 0 
 #define BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings )    \
  BOOST_PP_EMPTY                                                               \
  BOOST_PP_CAT( BOOST_PP_WHILE_, d )                                           \
  ( BOOST_DETAIL_BINARY_LITERAL_PREDICATE                                      \
  , BOOST_DETAIL_BINARY_LITERAL_OPERATION                                      \
  , bit_groupings ()                                                           \
  ) 
 #define BOOST_DETAIL_BINARY_LITERAL_PREDICATE( d, state )                      \
  BOOST_DETAIL_FIXED_COMPL( BOOST_DETAIL_IS_NULLARY_ARGS( state ) ) 
 #define BOOST_DETAIL_BINARY_LITERAL_OPERATION( d, state )                      \
  BOOST_DETAIL_SPLIT_AND_SWAP                                                  \
  ( BOOST_PP_CAT( BOOST_DETAIL_BINARY_LITERAL_ELEMENT_, state ) ) 
 #define BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION( s, dummy_param, tuple )        \
  BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL tuple 
 #define BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL( bit2, bit1, bit0 )               \
  BOOST_DETAIL_TRIPLE_TO_OCTAL_ ## bit2 ## bit1 ## bit0 
 #define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_1 (0)(0)
 #define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_2 (0)
 #define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_0  
 #define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1END_BIT  
 #define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1( bit )        \
  ( ( bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2 
 #define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2( bit )        \
  bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3 
 #define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3( bit )        \
  bit ) ) BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 
 #define BOOST_DETAIL_SPLIT_AND_SWAP( params )                                  \
  BOOST_PP_IDENTITY( BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS )()( params )
 #define BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS( first_param, second_param )        \
  second_param first_param 
 #define BOOST_DETAIL_LEFT_OF_COMMA( params )                                   \
  BOOST_PP_IDENTITY( BOOST_DETAIL_FIRST_MACRO_PARAM )()( params ) 
 #define BOOST_DETAIL_FIRST_MACRO_PARAM( first_param, second_param )            \
  first_param 
 /* Begin derived concepts from Chaos by Paul Mensonides */
 #define BOOST_DETAIL_IS_NULLARY_ARGS( param )                                  \
  BOOST_DETAIL_LEFT_OF_COMMA                                                   \
  ( BOOST_PP_CAT( BOOST_DETAIL_IS_NULLARY_ARGS_R_                              \
                , BOOST_DETAIL_IS_NULLARY_ARGS_C param                         \
                )                                                              \
  ) 
 #define BOOST_DETAIL_IS_NULLARY_ARGS_C()                                       \
  1 
 #define BOOST_DETAIL_IS_NULLARY_ARGS_R_1                                       \
  1, BOOST_PP_NIL 
 #define BOOST_DETAIL_IS_NULLARY_ARGS_R_BOOST_DETAIL_IS_NULLARY_ARGS_C          \
  0, BOOST_PP_NIL 
 /* End derived concepts from Chaos by Paul Mensonides */
 #define BOOST_DETAIL_TRIPLE_TO_OCTAL_000 0 
 #define BOOST_DETAIL_TRIPLE_TO_OCTAL_001 1 
 #define BOOST_DETAIL_TRIPLE_TO_OCTAL_010 2 
 #define BOOST_DETAIL_TRIPLE_TO_OCTAL_011 3 
 #define BOOST_DETAIL_TRIPLE_TO_OCTAL_100 4 
 #define BOOST_DETAIL_TRIPLE_TO_OCTAL_101 5 
 #define BOOST_DETAIL_TRIPLE_TO_OCTAL_110 6 
 #define BOOST_DETAIL_TRIPLE_TO_OCTAL_111 7 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0 (0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1 (1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000 (0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001 (0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010 (0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011 (0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100 (1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101 (1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110 (1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111 (1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000 (0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001 (0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010 (0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011 (0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100 (0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101 (0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110 (0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111 (0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000 (1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001 (1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010 (1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011 (1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100 (1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101 (1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110 (1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111 (1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000 (0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001 (0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010 (0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011 (0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100 (0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101 (0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110 (0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111 (0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000 (0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001 (0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010 (0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011 (0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100 (0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101 (0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110 (0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111 (0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000 (1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001 (1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010 (1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011 (1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100 (1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101 (1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110 (1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111 (1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000 (1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001 (1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010 (1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011 (1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100 (1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101 (1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110 (1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111 (1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000000 (0)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000001 (0)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000010 (0)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000011 (0)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000100 (0)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000101 (0)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000110 (0)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000111 (0)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001000 (0)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001001 (0)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001010 (0)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001011 (0)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001100 (0)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001101 (0)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001110 (0)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001111 (0)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010000 (0)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010001 (0)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010010 (0)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010011 (0)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010100 (0)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010101 (0)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010110 (0)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010111 (0)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011000 (0)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011001 (0)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011010 (0)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011011 (0)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011100 (0)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011101 (0)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011110 (0)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011111 (0)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100000 (1)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100001 (1)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100010 (1)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100011 (1)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100100 (1)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100101 (1)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100110 (1)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100111 (1)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101000 (1)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101001 (1)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101010 (1)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101011 (1)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101100 (1)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101101 (1)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101110 (1)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101111 (1)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110000 (1)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110001 (1)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110010 (1)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110011 (1)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110100 (1)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110101 (1)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110110 (1)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110111 (1)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111000 (1)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111001 (1)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111010 (1)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111011 (1)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111100 (1)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111101 (1)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111110 (1)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111111 (1)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000000 (0)(0)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000001 (0)(0)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000010 (0)(0)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000011 (0)(0)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000100 (0)(0)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000101 (0)(0)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000110 (0)(0)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000111 (0)(0)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001000 (0)(0)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001001 (0)(0)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001010 (0)(0)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001011 (0)(0)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001100 (0)(0)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001101 (0)(0)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001110 (0)(0)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001111 (0)(0)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010000 (0)(0)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010001 (0)(0)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010010 (0)(0)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010011 (0)(0)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010100 (0)(0)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010101 (0)(0)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010110 (0)(0)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010111 (0)(0)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011000 (0)(0)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011001 (0)(0)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011010 (0)(0)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011011 (0)(0)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011100 (0)(0)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011101 (0)(0)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011110 (0)(0)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011111 (0)(0)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100000 (0)(1)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100001 (0)(1)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100010 (0)(1)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100011 (0)(1)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100100 (0)(1)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100101 (0)(1)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100110 (0)(1)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100111 (0)(1)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101000 (0)(1)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101001 (0)(1)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101010 (0)(1)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101011 (0)(1)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101100 (0)(1)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101101 (0)(1)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101110 (0)(1)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101111 (0)(1)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110000 (0)(1)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110001 (0)(1)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110010 (0)(1)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110011 (0)(1)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110100 (0)(1)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110101 (0)(1)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110110 (0)(1)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110111 (0)(1)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111000 (0)(1)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111001 (0)(1)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111010 (0)(1)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111011 (0)(1)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111100 (0)(1)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111101 (0)(1)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111110 (0)(1)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111111 (0)(1)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000000 (1)(0)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000001 (1)(0)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000010 (1)(0)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000011 (1)(0)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000100 (1)(0)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000101 (1)(0)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000110 (1)(0)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000111 (1)(0)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001000 (1)(0)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001001 (1)(0)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001010 (1)(0)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001011 (1)(0)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001100 (1)(0)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001101 (1)(0)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001110 (1)(0)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001111 (1)(0)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010000 (1)(0)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010001 (1)(0)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010010 (1)(0)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010011 (1)(0)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010100 (1)(0)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010101 (1)(0)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010110 (1)(0)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010111 (1)(0)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011000 (1)(0)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011001 (1)(0)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011010 (1)(0)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011011 (1)(0)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011100 (1)(0)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011101 (1)(0)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011110 (1)(0)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011111 (1)(0)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100000 (1)(1)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100001 (1)(1)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100010 (1)(1)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100011 (1)(1)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100100 (1)(1)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100101 (1)(1)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100110 (1)(1)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100111 (1)(1)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101000 (1)(1)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101001 (1)(1)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101010 (1)(1)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101011 (1)(1)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101100 (1)(1)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101101 (1)(1)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101110 (1)(1)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101111 (1)(1)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110000 (1)(1)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110001 (1)(1)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110010 (1)(1)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110011 (1)(1)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110100 (1)(1)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110101 (1)(1)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110110 (1)(1)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110111 (1)(1)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111000 (1)(1)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111001 (1)(1)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111010 (1)(1)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111011 (1)(1)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111100 (1)(1)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111101 (1)(1)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111110 (1)(1)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111111 (1)(1)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000000 (0)(0)(0)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000001 (0)(0)(0)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000010 (0)(0)(0)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000011 (0)(0)(0)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000100 (0)(0)(0)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000101 (0)(0)(0)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000110 (0)(0)(0)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000111 (0)(0)(0)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001000 (0)(0)(0)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001001 (0)(0)(0)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001010 (0)(0)(0)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001011 (0)(0)(0)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001100 (0)(0)(0)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001101 (0)(0)(0)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001110 (0)(0)(0)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001111 (0)(0)(0)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010000 (0)(0)(0)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010001 (0)(0)(0)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010010 (0)(0)(0)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010011 (0)(0)(0)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010100 (0)(0)(0)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010101 (0)(0)(0)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010110 (0)(0)(0)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010111 (0)(0)(0)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011000 (0)(0)(0)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011001 (0)(0)(0)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011010 (0)(0)(0)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011011 (0)(0)(0)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011100 (0)(0)(0)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011101 (0)(0)(0)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011110 (0)(0)(0)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011111 (0)(0)(0)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100000 (0)(0)(1)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100001 (0)(0)(1)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100010 (0)(0)(1)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100011 (0)(0)(1)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100100 (0)(0)(1)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100101 (0)(0)(1)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100110 (0)(0)(1)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100111 (0)(0)(1)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101000 (0)(0)(1)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101001 (0)(0)(1)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101010 (0)(0)(1)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101011 (0)(0)(1)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101100 (0)(0)(1)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101101 (0)(0)(1)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101110 (0)(0)(1)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101111 (0)(0)(1)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110000 (0)(0)(1)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110001 (0)(0)(1)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110010 (0)(0)(1)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110011 (0)(0)(1)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110100 (0)(0)(1)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110101 (0)(0)(1)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110110 (0)(0)(1)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110111 (0)(0)(1)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111000 (0)(0)(1)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111001 (0)(0)(1)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111010 (0)(0)(1)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111011 (0)(0)(1)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111100 (0)(0)(1)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111101 (0)(0)(1)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111110 (0)(0)(1)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111111 (0)(0)(1)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000000 (0)(1)(0)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000001 (0)(1)(0)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000010 (0)(1)(0)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000011 (0)(1)(0)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000100 (0)(1)(0)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000101 (0)(1)(0)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000110 (0)(1)(0)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000111 (0)(1)(0)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001000 (0)(1)(0)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001001 (0)(1)(0)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001010 (0)(1)(0)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001011 (0)(1)(0)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001100 (0)(1)(0)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001101 (0)(1)(0)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001110 (0)(1)(0)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001111 (0)(1)(0)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010000 (0)(1)(0)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010001 (0)(1)(0)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010010 (0)(1)(0)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010011 (0)(1)(0)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010100 (0)(1)(0)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010101 (0)(1)(0)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010110 (0)(1)(0)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010111 (0)(1)(0)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011000 (0)(1)(0)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011001 (0)(1)(0)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011010 (0)(1)(0)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011011 (0)(1)(0)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011100 (0)(1)(0)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011101 (0)(1)(0)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011110 (0)(1)(0)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011111 (0)(1)(0)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100000 (0)(1)(1)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100001 (0)(1)(1)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100010 (0)(1)(1)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100011 (0)(1)(1)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100100 (0)(1)(1)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100101 (0)(1)(1)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100110 (0)(1)(1)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100111 (0)(1)(1)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101000 (0)(1)(1)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101001 (0)(1)(1)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101010 (0)(1)(1)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101011 (0)(1)(1)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101100 (0)(1)(1)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101101 (0)(1)(1)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101110 (0)(1)(1)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101111 (0)(1)(1)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110000 (0)(1)(1)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110001 (0)(1)(1)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110010 (0)(1)(1)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110011 (0)(1)(1)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110100 (0)(1)(1)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110101 (0)(1)(1)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110110 (0)(1)(1)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110111 (0)(1)(1)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111000 (0)(1)(1)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111001 (0)(1)(1)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111010 (0)(1)(1)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111011 (0)(1)(1)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111100 (0)(1)(1)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111101 (0)(1)(1)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111110 (0)(1)(1)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111111 (0)(1)(1)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000000 (1)(0)(0)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000001 (1)(0)(0)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000010 (1)(0)(0)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000011 (1)(0)(0)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000100 (1)(0)(0)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000101 (1)(0)(0)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000110 (1)(0)(0)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000111 (1)(0)(0)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001000 (1)(0)(0)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001001 (1)(0)(0)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001010 (1)(0)(0)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001011 (1)(0)(0)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001100 (1)(0)(0)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001101 (1)(0)(0)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001110 (1)(0)(0)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001111 (1)(0)(0)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010000 (1)(0)(0)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010001 (1)(0)(0)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010010 (1)(0)(0)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010011 (1)(0)(0)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010100 (1)(0)(0)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010101 (1)(0)(0)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010110 (1)(0)(0)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010111 (1)(0)(0)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011000 (1)(0)(0)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011001 (1)(0)(0)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011010 (1)(0)(0)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011011 (1)(0)(0)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011100 (1)(0)(0)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011101 (1)(0)(0)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011110 (1)(0)(0)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011111 (1)(0)(0)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100000 (1)(0)(1)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100001 (1)(0)(1)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100010 (1)(0)(1)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100011 (1)(0)(1)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100100 (1)(0)(1)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100101 (1)(0)(1)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100110 (1)(0)(1)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100111 (1)(0)(1)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101000 (1)(0)(1)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101001 (1)(0)(1)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101010 (1)(0)(1)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101011 (1)(0)(1)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101100 (1)(0)(1)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101101 (1)(0)(1)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101110 (1)(0)(1)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101111 (1)(0)(1)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110000 (1)(0)(1)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110001 (1)(0)(1)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110010 (1)(0)(1)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110011 (1)(0)(1)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110100 (1)(0)(1)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110101 (1)(0)(1)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110110 (1)(0)(1)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110111 (1)(0)(1)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111000 (1)(0)(1)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111001 (1)(0)(1)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111010 (1)(0)(1)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111011 (1)(0)(1)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111100 (1)(0)(1)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111101 (1)(0)(1)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111110 (1)(0)(1)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111111 (1)(0)(1)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000000 (1)(1)(0)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000001 (1)(1)(0)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000010 (1)(1)(0)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000011 (1)(1)(0)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000100 (1)(1)(0)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000101 (1)(1)(0)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000110 (1)(1)(0)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000111 (1)(1)(0)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001000 (1)(1)(0)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001001 (1)(1)(0)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001010 (1)(1)(0)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001011 (1)(1)(0)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001100 (1)(1)(0)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001101 (1)(1)(0)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001110 (1)(1)(0)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001111 (1)(1)(0)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010000 (1)(1)(0)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010001 (1)(1)(0)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010010 (1)(1)(0)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010011 (1)(1)(0)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010100 (1)(1)(0)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010101 (1)(1)(0)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010110 (1)(1)(0)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010111 (1)(1)(0)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011000 (1)(1)(0)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011001 (1)(1)(0)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011010 (1)(1)(0)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011011 (1)(1)(0)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011100 (1)(1)(0)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011101 (1)(1)(0)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011110 (1)(1)(0)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011111 (1)(1)(0)(1)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100000 (1)(1)(1)(0)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100001 (1)(1)(1)(0)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100010 (1)(1)(1)(0)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100011 (1)(1)(1)(0)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100100 (1)(1)(1)(0)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100101 (1)(1)(1)(0)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100110 (1)(1)(1)(0)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100111 (1)(1)(1)(0)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101000 (1)(1)(1)(0)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101001 (1)(1)(1)(0)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101010 (1)(1)(1)(0)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101011 (1)(1)(1)(0)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101100 (1)(1)(1)(0)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101101 (1)(1)(1)(0)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101110 (1)(1)(1)(0)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101111 (1)(1)(1)(0)(1)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110000 (1)(1)(1)(1)(0)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110001 (1)(1)(1)(1)(0)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110010 (1)(1)(1)(1)(0)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110011 (1)(1)(1)(1)(0)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110100 (1)(1)(1)(1)(0)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110101 (1)(1)(1)(1)(0)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110110 (1)(1)(1)(1)(0)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110111 (1)(1)(1)(1)(0)(1)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111000 (1)(1)(1)(1)(1)(0)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111001 (1)(1)(1)(1)(1)(0)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111010 (1)(1)(1)(1)(1)(0)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111011 (1)(1)(1)(1)(1)(0)(1)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111100 (1)(1)(1)(1)(1)(1)(0)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111101 (1)(1)(1)(1)(1)(1)(0)(1), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111110 (1)(1)(1)(1)(1)(1)(1)(0), 
 #define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111111 (1)(1)(1)(1)(1)(1)(1)(1), 
 #endif
--- a/include/boost/utility/compare_pointees.hpp
+++ b/include/boost/utility/compare_pointees.hpp
@ -0,0 +1,68 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // See http://www.boost.org/libs/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
 #ifndef BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
 #define BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
 #include<functional>
 namespace boost {
 // template<class OP> bool equal_pointees(OP const& x, OP const& y);
 // template<class OP> struct equal_pointees_t;
 //
 // Being OP a model of OptionalPointee (either a pointer or an optional):
 //
 // If both x and y have valid pointees, returns the result of (*x == *y)
 // If only one has a valid pointee, returns false.
 // If none have valid pointees, returns true.
 // No-throw
 template<class OptionalPointee>
 inline
 bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
 {
  return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
 }
 template<class OptionalPointee>
 struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
 {
  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return equal_pointees(x,y) ; }
 } ;
 // template<class OP> bool less_pointees(OP const& x, OP const& y);
 // template<class OP> struct less_pointees_t;
 //
 // Being OP a model of OptionalPointee (either a pointer or an optional):
 //
 // If y has not a valid pointee, returns false.
 // ElseIf x has not a valid pointee, returns true.
 // ElseIf both x and y have valid pointees, returns the result of (*x < *y)
 // No-throw
 template<class OptionalPointee>
 inline
 bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
 {
  return !y ? false : ( !x ? true : (*x) < (*y) ) ;
 }
 template<class OptionalPointee>
 struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
 {
  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return less_pointees(x,y) ; }
 } ;
 } // namespace boost
 #endif
--- a/include/boost/utility/declval.hpp
+++ b/include/boost/utility/declval.hpp
@ -0,0 +1,44 @@
 //  common_type.hpp  ---------------------------------------------------------//
 //  Copyright 2010 Vicente J. Botet Escriba
 //  Distributed under the Boost Software License, Version 1.0.
 //  See http://www.boost.org/LICENSE_1_0.txt
 #ifndef BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
 #define BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
 #include <boost/config.hpp>
 //----------------------------------------------------------------------------//
 #include <boost/type_traits/add_rvalue_reference.hpp>
 //----------------------------------------------------------------------------//
 //                                                                            //
 //                           C++03 implementation of                          //
 //                          Written by Vicente J. Botet Escriba               //
 //~ 20.3.4 Function template declval [declval]
 //~ 1 The library provides the function template declval to simplify the definition of expressions which occur as
 //~ unevaluated operands.
 //~ 2 Remarks: If this function is used, the program is ill-formed.
 //~ 3 Remarks: The template parameter T of declval may be an incomplete type.
 //~ [ Example:
 //~ template <class To, class From>
 //~ decltype(static_cast<To>(declval<From>())) convert(From&&);
 //~ declares a function template convert which only participats in overloading if the type From can be
 //~ explicitly converted to type To. For another example see class template common_type (20.7.6.6). <20>end
 //~ example ]
 //                                                                            //
 //----------------------------------------------------------------------------//
 namespace boost {
    template <typename T>
    typename add_rvalue_reference<T>::type declval(); //noexcept; // as unevaluated operand
 }  // namespace boost
 #endif  // BOOST_TYPE_TRAITS_EXT_DECLVAL__HPP
--- a/include/boost/utility/detail/in_place_factory_prefix.hpp
+++ b/include/boost/utility/detail/in_place_factory_prefix.hpp
@ -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/libs/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/libs/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,142 @@
 // 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
 // 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 tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
    : mpl::if_<
          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
        , boost::detail::tr1_result_of_impl<
            typename remove_cv<F>::type, 
            typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS), 
            (boost::detail::has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F(BOOST_RESULT_OF_ARGS), 
            (boost::detail::has_result_type<F>::value)> >::type { };
 #endif
 #if !defined(BOOST_NO_DECLTYPE) && defined(BOOST_RESULT_OF_USE_DECLTYPE)
 // Uses declval following N3225 20.7.7.6 when F is not a pointer.
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
    : mpl::if_<
          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type, 
            typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
          >
        , detail::cpp0x_result_of_impl<
              F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))
          >
      >::type
 {};
 namespace detail {
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
 {
  typedef decltype(
    boost::declval<F>()(
      BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), declval<T, >() BOOST_PP_INTERCEPT)
    )
  ) type;
 };
 } // namespace detail 
 #else // defined(BOOST_NO_DECLTYPE)
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct result_of<F(BOOST_RESULT_OF_ARGS)>
    : tr1_result_of<F(BOOST_RESULT_OF_ARGS)> { };
 #endif
 #endif // defined(BOOST_NO_DECLTYPE)
 #undef BOOST_RESULT_OF_ARGS
 #if BOOST_PP_ITERATION() >= 1 
 namespace detail {
 template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
  typedef R type;
 };
 template<typename R,  typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (&)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
 {
  typedef R type;
 };
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 template<typename R, typename FArgs BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct tr1_result_of_impl<R (T0::*)
                     (BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T)),
                 FArgs, false>
 {
  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 tr1_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 tr1_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 tr1_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
@ -0,0 +1,119 @@
 // Boost enable_if library
 // Copyright 2003 (c) The Trustees of Indiana University.
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 #ifndef BOOST_UTILITY_ENABLE_IF_HPP
 #define BOOST_UTILITY_ENABLE_IF_HPP
 #include "boost/config.hpp"
 // Even the definition of enable_if causes problems on some compilers,
 // so it's macroed out for all compilers that do not support SFINAE
 #ifndef BOOST_NO_SFINAE
 namespace boost
 {
  template <bool B, class T = void>
  struct enable_if_c {
    typedef T type;
  };
  template <class T>
  struct enable_if_c<false, T> {};
  template <class Cond, class T = void> 
  struct enable_if : public enable_if_c<Cond::value, T> {};
  template <bool B, class T>
  struct lazy_enable_if_c {
    typedef typename T::type type;
  };
  template <class T>
  struct lazy_enable_if_c<false, T> {};
  template <class Cond, class T> 
  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
  template <bool B, class T = void>
  struct disable_if_c {
    typedef T type;
  };
  template <class T>
  struct disable_if_c<true, T> {};
  template <class Cond, class T = void> 
  struct disable_if : public disable_if_c<Cond::value, T> {};
  template <bool B, class T>
  struct lazy_disable_if_c {
    typedef typename T::type type;
  };
  template <class T>
  struct lazy_disable_if_c<true, T> {};
  template <class Cond, class T> 
  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
 } // namespace boost
 #else
 namespace boost {
  namespace detail { typedef void enable_if_default_T; }
  template <typename T>
  struct enable_if_does_not_work_on_this_compiler;
  template <bool B, class T = detail::enable_if_default_T>
  struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
  { };
  template <bool B, class T = detail::enable_if_default_T> 
  struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
  { };
  template <bool B, class T = detail::enable_if_default_T> 
  struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
  { };
  template <bool B, class T = detail::enable_if_default_T> 
  struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
  { };
  template <class Cond, class T = detail::enable_if_default_T> 
  struct enable_if : enable_if_does_not_work_on_this_compiler<T>
  { };
  template <class Cond, class T = detail::enable_if_default_T> 
  struct disable_if : enable_if_does_not_work_on_this_compiler<T>
  { };
  template <class Cond, class T = detail::enable_if_default_T> 
  struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
  { };
  template <class Cond, class T = detail::enable_if_default_T> 
  struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
  { };
 } // namespace boost
 #endif // BOOST_NO_SFINAE
 #endif
--- 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/libs/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,103 @@
 // 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_binary_params.hpp> 
 #include <boost/preprocessor/repetition/enum_shifted_params.hpp> 
 #include <boost/preprocessor/facilities/intercept.hpp> 
 #include <boost/detail/workaround.hpp>
 #include <boost/mpl/has_xxx.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/or.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/utility/declval.hpp>
 #ifndef BOOST_RESULT_OF_NUM_ARGS
 #  define BOOST_RESULT_OF_NUM_ARGS 10
 #endif
 namespace boost {
 template<typename F> struct result_of;
 template<typename F> struct tr1_result_of; // a TR1-style implementation of result_of
 #if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 namespace detail {
 BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
 template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
 template<typename F> struct cpp0x_result_of_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;
 };
 // Determine the return type of a function pointer or pointer to member.
 template<typename F, typename FArgs>
 struct result_of_pointer
  : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
 template<typename F, typename FArgs>
 struct tr1_result_of_impl<F, FArgs, true>
 {
  typedef typename F::result_type type;
 };
 template<typename FArgs>
 struct is_function_with_no_args : mpl::false_ {};
 template<typename F>
 struct is_function_with_no_args<F(void)> : mpl::true_ {};
 template<typename F, typename FArgs>
 struct result_of_nested_result : F::template result<FArgs>
 {};
 template<typename F, typename FArgs>
 struct tr1_result_of_impl<F, FArgs, false>
  : mpl::if_<is_function_with_no_args<FArgs>,
             result_of_void_impl<F>,
             result_of_nested_result<F, FArgs> >::type
 {};
 } // end namespace detail
 #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/swap.hpp
+++ b/include/boost/utility/swap.hpp
@ -0,0 +1,55 @@
 // Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // For more information, see http://www.boost.org
 #ifndef BOOST_UTILITY_SWAP_HPP
 #define BOOST_UTILITY_SWAP_HPP
 // Note: the implementation of this utility contains various workarounds:
 // - swap_impl is put outside the boost namespace, to avoid infinite
 // recursion (causing stack overflow) when swapping objects of a primitive
 // type.
 // - swap_impl has a using-directive, rather than a using-declaration,
 // because some compilers (including MSVC 7.1, Borland 5.9.3, and
 // Intel 8.1) don't do argument-dependent lookup when it has a
 // using-declaration instead.
 // - boost::swap has two template arguments, instead of one, to
 // avoid ambiguity when swapping objects of a Boost type that does
 // not have its own boost::swap overload.
 #include <algorithm> //for std::swap
 #include <cstddef> //for std::size_t
 namespace boost_swap_impl
 {
  template<class T>
  void swap_impl(T& left, T& right)
  {
    using namespace std;//use std::swap if argument dependent lookup fails
    swap(left,right);
  }
  template<class T, std::size_t N>
  void swap_impl(T (& left)[N], T (& right)[N])
  {
    for (std::size_t i = 0; i < N; ++i)
    {
      ::boost_swap_impl::swap_impl(left[i], right[i]);
    }
  }
 }
 namespace boost
 {
  template<class T1, class T2>
  void swap(T1& left, T2& right)
  {
    ::boost_swap_impl::swap_impl(left, right);
  }
 }
 #endif
--- a/include/boost/utility/typed_in_place_factory.hpp
+++ b/include/boost/utility/typed_in_place_factory.hpp
@ -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/libs/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
@ -0,0 +1,258 @@
 // (C) Copyright 2002-2008, Fernando Luis Cacciola Carballal.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // 21 Ago 2002 (Created) Fernando Cacciola
 // 24 Dec 2007 (Refactored and worked around various compiler bugs) Fernando Cacciola, Niels Dekker
 // 23 May 2008 (Fixed operator= const issue, added initialized_value) Niels Dekker, Fernando Cacciola
 // 21 Ago 2008 (Added swap) Niels Dekker, Fernando Cacciola
 // 20 Feb 2009 (Fixed logical const-ness issues) Niels Dekker, Fernando Cacciola
 // 03 Apr 2010 (Added initialized<T>, suggested by Jeffrey Hellrung, fixing #3472) Niels Dekker
 // 30 May 2010 (Made memset call conditional, fixing #3869) Niels Dekker
 //
 #ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
 #define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
 // Note: The implementation of boost::value_initialized had to deal with the
 // fact that various compilers haven't fully implemented value-initialization.
 // The constructor of boost::value_initialized<T> works around these compiler
 // issues, by clearing the bytes of T, before constructing the T object it
 // contains. More details on these issues are at libs/utility/value_init.htm
 #include <boost/aligned_storage.hpp>
 #include <boost/config.hpp> // For BOOST_NO_COMPLETE_VALUE_INITIALIZATION.
 #include <boost/detail/workaround.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/cv_traits.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <boost/swap.hpp>
 #include <cstring>
 #include <new>
 #ifdef BOOST_MSVC
 #pragma warning(push)
 #if _MSC_VER >= 1310
 // It is safe to ignore the following warning from MSVC 7.1 or higher:
 // "warning C4351: new behavior: elements of array will be default initialized"
 #pragma warning(disable: 4351)
 // It is safe to ignore the following MSVC warning, which may pop up when T is 
 // a const type: "warning C4512: assignment operator could not be generated".
 #pragma warning(disable: 4512)
 #endif
 #endif
 #ifdef BOOST_NO_COMPLETE_VALUE_INITIALIZATION
  // Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED 
  // suggests that a workaround should be applied, because of compiler issues 
  // regarding value-initialization.
  #define BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
 #endif
 // Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND
 // switches the value-initialization workaround either on or off.
 #ifndef BOOST_DETAIL_VALUE_INIT_WORKAROUND
  #ifdef BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
  #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 1
  #else
  #define BOOST_DETAIL_VALUE_INIT_WORKAROUND 0
  #endif
 #endif
 namespace boost {
 template<class T>
 class initialized
 {
  private :
    struct wrapper
    {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
      typename
 #endif 
      remove_const<T>::type data;
      wrapper()
      :
      data()
      {
      }
      wrapper(T const & arg)
      :
      data(arg)
      {
      }
    };
    mutable
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
      typename
 #endif 
      aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;
    wrapper * wrapper_address() const
    {
      return static_cast<wrapper *>( static_cast<void*>(&x));
    }
  public :
    initialized()
    {
 #if BOOST_DETAIL_VALUE_INIT_WORKAROUND
      std::memset(&x, 0, sizeof(x));
 #endif
      new (wrapper_address()) wrapper();
    }
    initialized(initialized const & arg)
    {
      new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
    }
    explicit initialized(T const & arg)
    {
      new (wrapper_address()) wrapper(arg);
    }
    initialized & operator=(initialized const & arg)
    {
      // Assignment is only allowed when T is non-const.
      BOOST_STATIC_ASSERT( ! is_const<T>::value );
      *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
      return *this;
    }
    ~initialized()
    {
      wrapper_address()->wrapper::~wrapper();
    }
    T const & data() const
    {
      return wrapper_address()->data;
    }
    T& data()
    {
      return wrapper_address()->data;
    }
    void swap(initialized & arg)
    {
      ::boost::swap( this->data(), arg.data() );
    }
    operator T const &() const
    {
      return wrapper_address()->data;
    }
    operator T&()
    {
      return wrapper_address()->data;
    }
 } ;
 template<class T>
 T const& get ( initialized<T> const& x )
 {
  return x.data() ;
 }
 template<class T>
 T& get ( initialized<T>& x )
 {
  return x.data() ;
 }
 template<class T>
 void swap ( initialized<T> & lhs, initialized<T> & rhs )
 {
  lhs.swap(rhs) ;
 }
 template<class T>
 class value_initialized
 {
  private :
    // initialized<T> does value-initialization by default.
    initialized<T> m_data;
  public :
    value_initialized()
    :
    m_data()
    { }
    T const & data() const
    {
      return m_data.data();
    }
    T& data()
    {
      return m_data.data();
    }
    void swap(value_initialized & arg)
    {
      m_data.swap(arg.m_data);
    }
    operator T const &() const
    {
      return m_data;
    }
    operator T&()
    {
      return m_data;
    }
 } ;
 template<class T>
 T const& get ( value_initialized<T> const& x )
 {
  return x.data() ;
 }
 template<class T>
 T& get ( value_initialized<T>& x )
 {
  return x.data() ;
 }
 template<class T>
 void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
 {
  lhs.swap(rhs) ;
 }
 class initialized_value_t
 {
  public :
    template <class T> operator T() const
    {
      return initialized<T>().data();
    }
 };
 initialized_value_t const initialized_value = {} ;
 } // namespace boost
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif
 #endif
--- a/include/boost/utility_fwd.hpp
+++ b/include/boost/utility_fwd.hpp
@ -1,34 +0,0 @@
 //  Boost utility_fwd.hpp header file  ---------------------------------------//
 //  (C) Copyright boost.org 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.
 #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/utility.hpp>  ------------------------------------------------//
 class noncopyable;
 // Also has a few function templates
 }  // namespace boost
 #endif  // BOOST_UTILITY_FWD_HPP
--- a/index.html
+++ b/index.html
@ -1,34 +1,50 @@
 <html>
-
+	<head>
-<head>
+		<meta http-equiv="Content-Language" content="en-us">
-<meta http-equiv="Content-Language" content="en-us">
+		<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+		<meta name="ProgId" content="FrontPage.Editor.Document">
-<meta name="ProgId" content="FrontPage.Editor.Document">
+		<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+		<title>Boost Utility Library</title>
-<title>Boost Utility Library</title>
+	</head>
-</head>
+	<body bgcolor="#FFFFFF">
-
+		<h1><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86" align="center">Boost 
-<body bgcolor="#FFFFFF">
+			Utility Library</h1>
-
+		<p>The Boost Utility Library isn't really a single library at all. It is just a 
-<h1><IMG SRC="../../c++boost.gif" WIDTH="276" HEIGHT="86" align="center">Boost 
+			collection for components too small to be called libraries in their own right.</p>
-Utility Library</h1>
+		<p>But that doesn't mean there isn't useful stuff here. Take a look:</p>
-<p>The Boost Utility Library isn't really a single library at all.&nbsp; It is 
+		<blockquote>
-just a collection for components too small to be called libraries in their own 
+			<p>
-right.</p>
+				<a href="utility.htm#addressof">addressof</a><br>
-<p>But that doesn't mean there isn't useful stuff here.&nbsp; Take a look:</p>
+				<a href="assert.html">assert</a><br>
-<blockquote>
+				<a href="base_from_member.html">base_from_member</a><br>
-  <p><a href="base_from_member.html">base_from_member</a><br>
+				<a href="utility.htm#BOOST_BINARY">BOOST_BINARY</a><br>
-  <a href="call_traits.htm">call_traits.htm</a><br>
+				<a href="call_traits.htm">call_traits</a><br>
-  <a href="compressed_pair.htm">compressed_pair.htm</a><br>
+				<a href="checked_delete.html">checked_delete</a><br>
-  <a href="operators.htm">operators.htm</a><br>
+				<a href="compressed_pair.htm">compressed_pair</a><br>
-  <a href="tie.html">tie</a><br>
+				<a href="current_function.html">current_function</a><br>
-  <a href="utility.htm">utility.htm</a></p>
+            <a href="doc/html/declval.html">declval</a><br>
-</blockquote>
+            <a href="enable_if.html">enable_if</a><br>
-<hr>
+				<a href="in_place_factories.html">in_place_factory</a><br>
-<p>Revised
+            <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
-<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->07 May, 2002<!--webbot bot="Timestamp" endspan i-checksum="13976" --></p>
+            <a href="generator_iterator.htm">generator iterator adaptors</a><br>
-<p>&nbsp;</p>
+				<a href="utility.htm#functions_next_prior">next/prior</a><br>
-
+				<a href="utility.htm#Class_noncopyable">noncopyable</a><br>
-</body>
+				<a href="operators.htm">operators</a><br>
-
+				<a href="utility.htm#result_of">result_of</a><br>
 				<a href="swap.html">swap</a><br>
 				<a href="throw_exception.html">throw_exception</a><br>
 				<a href="utility.htm">utility</a><br>
            <a href="value_init.htm">value_init</a>
         </p>
 		</blockquote>
 		<hr>
 		<p>&copy; Copyright Beman Dawes, 2001</p>
        <p>Distributed under the Boost Software License, Version 1.0. (See 
        accompanying file <a href="../../LICENSE_1_0.txt">
        LICENSE_1_0.txt</a> or copy at
        <a href="http://www.boost.org/LICENSE_1_0.txt">
        www.boost.org/LICENSE_1_0.txt</a>)</p>
 		<p>Revised 
 			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->07 November, 2006<!--webbot bot="Timestamp" endspan i-checksum="39368" --></p>
 		</body>
 </html>
--- a/indirect_iterator.htm
+++ b/indirect_iterator.htm
@ -1,444 +0,0 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <html>
 <head>
    <meta name="generator" content="HTML Tidy, see www.w3.org">
    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
    <meta name="ProgId" content="FrontPage.Editor.Document">
    <title>Indirect 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"> 
    <h1>Indirect Iterator Adaptor</h1>
    Defined in header <a href=
    "../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a> 
    <p>The indirect iterator adaptor augments an iterator by applying an
    <b>extra</b> dereference inside of <tt>operator*()</tt>. For example, this
    iterator makes it possible to view a container of pointers or
    smart-pointers (e.g. <tt>std::list&lt;boost::shared_ptr&lt;foo&gt;
    &gt;</tt>) as if it were a container of the pointed-to type. The following
    <b>pseudo-code</b> shows the basic idea of the indirect iterator:
    <blockquote>
 <pre>
 // inside a hypothetical indirect_iterator class...
 typedef std::iterator_traits&lt;BaseIterator&gt;::value_type Pointer;
 typedef std::iterator_traits&lt;Pointer&gt;::reference reference;
 reference indirect_iterator::operator*() const {
  return **this-&gt;base_iterator;
 }
 </pre>
    </blockquote>
    <h2>Synopsis</h2>
    <blockquote>
 <pre>
 namespace boost {
  template &lt;class BaseIterator,
            class Value, class Reference, class Category, class Pointer&gt;
  struct indirect_iterator_generator;
  template &lt;class BaseIterator,
            class Value, class Reference, class ConstReference, 
            class Category, class Pointer, class ConstPointer&gt;
  struct indirect_iterator_pair_generator;
  template &lt;class BaseIterator&gt;
  typename indirect_iterator_generator&lt;BaseIterator&gt;::type
  make_indirect_iterator(BaseIterator base)  
 }
 </pre>
    </blockquote>
    <hr>
    <h2><a name="indirect_iterator_generator">The Indirect Iterator Type
    Generator</a></h2>
    The <tt>indirect_iterator_generator</tt> template is a <a href=
    "../../more/generic_programming.html#type_generator">generator</a> of
    indirect iterator types. The main template parameter for this class is the
    <tt>BaseIterator</tt> type that is being wrapped. In most cases the type of
    the elements being pointed to can be deduced using
    <tt>std::iterator_traits</tt>, but in some situations the user may want to
    override this type, so there are also template parameters that allow a user
    to control the <tt>value_type</tt>, <tt>pointer</tt>, and
    <tt>reference</tt> types of the resulting iterators. 
    <blockquote>
 <pre>
 template &lt;class BaseIterator,
          class Value, class Reference, class Pointer&gt;
 class indirect_iterator_generator
 {
 public:
  typedef <tt><a href=
 "./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> type; // the resulting indirect iterator type 
 };
 </pre>
    </blockquote>
    <h3>Example</h3>
    This example uses the <tt>indirect_iterator_generator</tt> to create
    indirect iterators which dereference the pointers stored in the
    <tt>pointers_to_chars</tt> array to access the <tt>char</tt>s in the
    <tt>characters</tt> array. 
    <blockquote>
 <pre>
 #include &lt;boost/config.hpp&gt;
 #include &lt;vector&gt;
 #include &lt;iostream&gt;
 #include &lt;iterator&gt;
 #include &lt;boost/iterator_adaptors.hpp&gt;
 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 &lt; N; ++i)
    pointers_to_chars[i] = &amp;characters[i];
  boost::indirect_iterator_generator&lt;char**, char&gt;::type 
    indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
  std::copy(indirect_first, indirect_last, std::ostream_iterator&lt;char&gt;(std::cout, ","));
  std::cout &lt;&lt; std::endl;
  // to be continued...
 </pre>
    </blockquote>
    <h3>Template Parameters</h3>
    <table border>
      <tr>
        <th>Parameter
        <th>Description
      <tr>
        <td><tt>BaseIterator</tt> 
        <td>The iterator type being wrapped. The <tt>value_type</tt>
        of the base iterator should itself be dereferenceable.  
        The return type of the <tt>operator*</tt> for the
        <tt>value_type</tt> should match the <tt>Reference</tt> type.
      <tr>
        <td><tt>Value</tt> 
        <td>The <tt>value_type</tt> of the resulting iterator, unless const. If
        Value is <tt>const X</tt>, a conforming compiler makes the
        <tt>value_type</tt> <tt><i>non-</i>const X</tt><a href=
        "iterator_adaptors.htm#1">[1]</a>. Note that if the default
         is used for <tt>Value</tt>, then there must be a valid specialization
         of <tt>iterator_traits</tt> for the value type of the base iterator.
         <br>
         <b>Default:</b> <tt>std::iterator_traits&lt;<br>
         <20> std::iterator_traits&lt;BaseIterator&gt;::value_type
        &gt;::value_type</tt><a href="#2">[2]</a> 
      <tr>
        <td><tt>Reference</tt> 
        <td>The <tt>reference</tt> type of the resulting iterator, and in
        particular, the result type of <tt>operator*()</tt>.<br>
         <b>Default:</b> <tt>Value&amp;</tt> 
      <tr>
        <td><tt>Pointer</tt> 
        <td>The <tt>pointer</tt> type of the resulting iterator, and in
        particular, the result type of <tt>operator-&gt;()</tt>.<br>
         <b>Default:</b> <tt>Value*</tt> 
      <tr>
        <td><tt>Category</tt> 
        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
         <b>Default:</b>
        <tt>std::iterator_traits&lt;BaseIterator&gt;::iterator_category</tt> 
    </table>
    <h3>Concept Model</h3>
    The indirect iterator will model whichever <a href=
    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator
    concept category</a> is modeled by the base iterator. Thus, if the
    base iterator is a model of <a href=
    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
    Access Iterator</a> then so is the resulting indirect iterator. If
    the base iterator models a more restrictive concept, the resulting
    indirect iterator will model the same concept <a href="#3">[3]</a>.
    <h3>Members</h3>
    The indirect iterator type implements the member functions and operators
    required of the <a href=
    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
    Iterator</a> concept. In addition it has the following constructor: 
 <pre>
 explicit indirect_iterator_generator::type(const BaseIterator&amp; it)
 </pre>
    <br>
     <br>
    <hr>
    <p>
    <h2><a name="indirect_iterator_pair_generator">The Indirect Iterator Pair
    Generator</a></h2>
    Sometimes a pair of <tt>const</tt>/non-<tt>const</tt> pair of iterators is
    needed, such as when implementing a container. The
    <tt>indirect_iterator_pair_generator</tt> class makes it more convenient to
    create this pair of iterator types. 
    <blockquote>
 <pre>
  template &lt;class BaseIterator,
            class Value, class Reference, class ConstReference, 
            class Category, class Pointer, class ConstPointer&gt;
  struct indirect_iterator_pair_generator;
 {
 public:
  typedef <tt><a href=
 "./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> iterator;       // the mutable indirect iterator type 
  typedef <tt><a href=
 "./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> const_iterator; // the immutable indirect iterator type 
 };
 </pre>
    </blockquote>
    <h3>Example</h3>
    <blockquote>
 <pre>
  // continuing from the last example...
  typedef boost::indirect_iterator_pair_generator&lt;char**,
    char, char*, char&amp;, const char*, const char&amp;&gt; PairGen;
  char mutable_characters[N];
  char* pointers_to_mutable_chars[N];
  for (int i = 0; i &lt; N; ++i)
    pointers_to_mutable_chars[i] = &amp;mutable_characters[i];
  PairGen::iterator mutable_indirect_first(pointers_to_mutable_chars),
    mutable_indirect_last(pointers_to_mutable_chars + N);
  PairGen::const_iterator 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&lt;char&gt;(), 1));
  std::copy(mutable_indirect_first, mutable_indirect_last,
      std::ostream_iterator&lt;char&gt;(std::cout, ","));
  std::cout &lt;&lt; std::endl;
  // to be continued...
 </pre>
    </blockquote>
    <p>The output is:
    <blockquote>
 <pre>
 b,c,d,e,f,g,h,
 </pre>
    </blockquote>
    <h3>Template Parameters</h3>
    <table border>
      <tr>
        <th>Parameter
        <th>Description
      <tr>
        <td><tt>BaseIterator</tt> 
        <td>The iterator type being wrapped. The <tt>value_type</tt> of the
        base iterator should itself be dereferenceable.
        The return type of the <tt>operator*</tt> for the
        <tt>value_type</tt> should match the <tt>Reference</tt> type.
      <tr>
        <td><tt>Value</tt> 
        <td>The <tt>value_type</tt> of the resulting iterators.
         If Value is <tt>const X</tt>, a conforming compiler makes the
         <tt>value_type</tt> <tt><i>non-</i>const X</tt><a href=
         "iterator_adaptors.htm#1">[1]</a>. Note that if the default
         is used for <tt>Value</tt>, then there must be a valid
         specialization of <tt>iterator_traits</tt> for the value type
         of the base iterator.<br>
         <b>Default:</b> <tt>std::iterator_traits&lt;<br>
         <20> std::iterator_traits&lt;BaseIterator&gt;::value_type
        &gt;::value_type</tt><a href="#2">[2]</a> 
      <tr>
        <td><tt>Reference</tt> 
        <td>The <tt>reference</tt> type of the resulting <tt>iterator</tt>, and
        in particular, the result type of its <tt>operator*()</tt>.<br>
         <b>Default:</b> <tt>Value&amp;</tt> 
      <tr>
        <td><tt>ConstReference</tt> 
        <td>The <tt>reference</tt> type of the resulting
        <tt>const_iterator</tt>, and in particular, the result type of its
        <tt>operator*()</tt>.<br>
         <b>Default:</b> <tt>const Value&amp;</tt> 
      <tr>
        <td><tt>Category</tt> 
        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
         <b>Default:</b>
        <tt>std::iterator_traits&lt;BaseIterator&gt;::iterator_category</tt> 
      <tr>
        <td><tt>Pointer</tt> 
        <td>The <tt>pointer</tt> type of the resulting <tt>iterator</tt>, and
        in particular, the result type of its <tt>operator-&gt;()</tt>.<br>
         <b>Default:</b> <tt>Value*</tt> 
      <tr>
        <td><tt>ConstPointer</tt> 
        <td>The <tt>pointer</tt> type of the resulting <tt>const_iterator</tt>,
        and in particular, the result type of its <tt>operator-&gt;()</tt>.<br>
         <b>Default:</b> <tt>const Value*</tt> 
    </table>
    <h3>Concept Model</h3>
    The indirect iterators will model whichever <a href=
    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator
    concept category</a> is modeled by the base iterator. Thus, if the
    base iterator is a model of <a href=
    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
    Access Iterator</a> then so are the resulting indirect
    iterators. If the base iterator models a more restrictive concept,
    the resulting indirect iterators will model the same concept <a
    href="#3">[3]</a>.
    <h3>Members</h3>
    The resulting <tt>iterator</tt> and <tt>const_iterator</tt> types implement
    the member functions and operators required of the <a href=
    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
    Iterator</a> concept. In addition they support the following constructors: 
    <blockquote>
 <pre>
 explicit indirect_iterator_pair_generator::iterator(const BaseIterator&amp; it)
 explicit indirect_iterator_pair_generator::const_iterator(const BaseIterator&amp; it)
 </pre>
    </blockquote>
    <br>
     <br>
    <hr>
    <p>
    <h2><a name="make_indirect_iterator">The Indirect Iterator Object
    Generator</a></h2>
    The <tt>make_indirect_iterator()</tt> function provides a more convenient
    way to create indirect iterator objects. The function saves the user the
    trouble of explicitly writing out the iterator types. 
    <blockquote>
 <pre>
 template &lt;class BaseIterator&gt;
 typename indirect_iterator_generator&lt;BaseIterator&gt;::type
 make_indirect_iterator(BaseIterator base)  
 </pre>
    </blockquote>
    <h3>Example</h3>
    Here we again print the <tt>char</tt>s from the array <tt>characters</tt>
    by accessing them through the array of pointers <tt>pointer_to_chars</tt>,
    but this time we use the <tt>make_indirect_iterator()</tt> function which
    saves us some typing. 
    <blockquote>
 <pre>
  // continuing from the last example...
  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
      boost::make_indirect_iterator(pointers_to_chars + N),
      std::ostream_iterator&lt;char&gt;(std::cout, ","));
  std::cout &lt;&lt; std::endl;
  return 0;
 }
 </pre>
    </blockquote>
    The output is: 
    <blockquote>
 <pre>
 a,b,c,d,e,f,g,
 </pre>
    </blockquote>
    <hr>
    <h3>Notes</h3>
    <p>
    <p><a name="2">[2]</a> If your compiler does not support partial
    specialization and the base iterator or its <tt>value_type</tt> is a
    builtin pointer type, you will not be able to use the default for
    <tt>Value</tt> and will need to specify this type explicitly.
    <p><a name="3">[3]</a>There is a caveat to which concept the
    indirect iterator can model.  If the return type of the
    <tt>operator*</tt> for the base iterator's value type is not a
    true reference, then strickly speaking, the indirect iterator can
    not be a model of <a href=
    "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
    Iterator</a> or any of the concepts that refine it. In this case
    the <tt>Category</tt> for the indirect iterator should be
    specified as <tt>std::input_iterator_tag</tt>. However, even in
    this case, if the base iterator is a random access iterator, the
    resulting indirect iterator will still satisfy most of the
    requirements for <a href=
    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
    Access Iterator</a>.
    <hr>
    <p>Revised 
    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->18 Sep 2001<!--webbot bot="Timestamp" endspan i-checksum="14941" -->
    <p>&copy; Copyright Jeremy Siek and David Abrahams 2001. 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. 
    <!--  LocalWords:  html charset alt gif hpp BaseIterator const namespace struct
             -->
    <!--  LocalWords:  ConstPointer ConstReference typename iostream int abcdefg
             -->
     <!--  LocalWords:  sizeof  PairGen pre Jeremy Siek David Abrahams
             -->
 </body>
 </html>
--- a/indirect_iterator_example.cpp
+++ b/indirect_iterator_example.cpp
@ -1,62 +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 <boost/iterator_adaptors.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_generator<char**, char>::type 
    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
  typedef boost::indirect_iterator_pair_generator<char**, char> PairGen;
  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];
  PairGen::iterator mutable_indirect_first(pointers_to_mutable_chars),
    mutable_indirect_last(pointers_to_mutable_chars + N);
  PairGen::const_iterator 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()
 #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
  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;
 #endif
  return 0;
 }
--- a/indirect_iterator_test.cpp
+++ b/indirect_iterator_test.cpp
@ -1,151 +0,0 @@
 //  (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.
 //  Revision History
 //  08 Mar 2001   Jeremy Siek
 //       Moved test of indirect iterator into its own file. It to
 //       to be in iterator_adaptor_test.cpp.
 #include <boost/config.hpp>
 #include <iostream>
 #include <algorithm>
 #include <boost/iterator_adaptors.hpp>
 #include <boost/pending/iterator_tests.hpp>
 #include <boost/concept_archetype.hpp>
 #include <stdlib.h>
 #include <deque>
 #include <set>
 struct my_iterator_tag : public std::random_access_iterator_tag { };
 using boost::dummyT;
 typedef std::deque<int> storage;
 typedef std::deque<int*> pointer_deque;
 typedef std::set<storage::iterator> iterator_set;
 void more_indirect_iterator_tests()
 {
 // For some reason all heck breaks loose in the compiler under these conditions.
 #if !defined(BOOST_MSVC) || BOOST_MSVC > 1200 || !defined(__STL_DEBUG)
    storage store(1000);
    std::generate(store.begin(), store.end(), rand);
    pointer_deque ptr_deque;
    iterator_set iter_set;
    for (storage::iterator p = store.begin(); p != store.end(); ++p)
    {
        ptr_deque.push_back(&*p);
        iter_set.insert(p);
    }
    typedef boost::indirect_iterator_pair_generator<
        pointer_deque::iterator
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
        , int
 #endif
    > IndirectDeque;
    IndirectDeque::iterator db(ptr_deque.begin());
    IndirectDeque::iterator de(ptr_deque.end());
    assert(static_cast<std::size_t>(de - db) == store.size());
    assert(db + store.size() == de);
    IndirectDeque::const_iterator dci(db);
    assert(db == dci);
    assert(dci == db);
    assert(dci != de);
    assert(dci < de);
    assert(dci <= de);
    assert(de >= dci);
    assert(de > dci);
    dci = de;
    assert(dci == de);
    boost::random_access_iterator_test(db + 1, store.size() - 1, boost::next(store.begin()));
    *db = 999;
    assert(store.front() == 999);
    // Borland C++ is getting very confused about the typedef's here
    typedef boost::indirect_iterator_generator<
        iterator_set::iterator
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
        , int
 #endif
        >::type indirect_set_iterator;
    typedef boost::indirect_iterator_generator<
        iterator_set::iterator,
        const int
        >::type const_indirect_set_iterator;
    indirect_set_iterator sb(iter_set.begin());
    indirect_set_iterator se(iter_set.end());
    const_indirect_set_iterator sci(iter_set.begin());
    assert(sci == sb);
    assert(sci != se);
    sci = se;
    assert(sci == se);
    *boost::prior(se) = 888;
    assert(store.back() == 888);
    assert(std::equal(sb, se, store.begin()));
    boost::bidirectional_iterator_test(boost::next(sb), store[1], store[2]);
    assert(std::equal(db, de, store.begin()));
 #endif    
 }
 int
 main()
 {
  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
                     dummyT(3), dummyT(4), dummyT(5) };
  const int N = sizeof(array)/sizeof(dummyT);
  // Test indirect_iterator_generator
  {
    dummyT* ptr[N];
    for (int k = 0; k < N; ++k)
      ptr[k] = array + k;
    typedef boost::indirect_iterator_generator<dummyT**
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
        , dummyT
 #endif
      >::type indirect_iterator;
    typedef boost::indirect_iterator_generator<dummyT**, const dummyT>::type const_indirect_iterator;
    indirect_iterator i(ptr);
    boost::random_access_iterator_test(i, N, array);
 #ifndef BOOST_NO_STD_ITERATOR_TRAITS
    boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
 #endif
    // check operator->
    assert((*i).m_x == i->foo());
    const_indirect_iterator j(ptr);
    boost::random_access_iterator_test(j, N, array);
    dummyT*const* const_ptr = ptr;
 #ifndef BOOST_NO_STD_ITERATOR_TRAITS
    boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr), N, array);
 #endif
    boost::const_nonconst_iterator_test(i, ++j);
    more_indirect_iterator_tests();
  }
  std::cout << "test successful " << std::endl;
  return 0;
 }
--- a/initialized_test.cpp
+++ b/initialized_test.cpp
@ -0,0 +1,116 @@
 // Copyright 2010, Niels Dekker.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // Test program for boost::initialized<T>.
 //
 // 2 May 2010 (Created) Niels Dekker
 #include <boost/utility/value_init.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <string>
 namespace
 {
  // Typical use case for boost::initialized<T>: A generic class that 
  // holds a value of type T, which must be initialized by either 
  // value-initialization or direct-initialization.
  template <class T> class key_value_pair
  {
    std::string m_key;
    boost::initialized<T> m_value;
  public:
    // Value-initializes the object held by m_value.
    key_value_pair() { }
    // Value-initializes the object held by m_value.
    explicit key_value_pair(const std::string& key)
    :
    m_key(key)
    {
    }
    // Direct-initializes the object held by m_value.
    key_value_pair(const std::string& key, const T& value)
    :
    m_key(key), m_value(value)
    {
    }
    const T& get_value() const
    {
      return m_value;
    }
  };
  // Tells whether the argument is value-initialized.
  bool is_value_initialized(const int& arg)
  {
    return arg == 0;
  }
  // Tells whether the argument is value-initialized.
  bool is_value_initialized(const std::string& arg)
  {
    return arg.empty();
  }
  struct foo
  {
    int data;
  };
  bool operator==(const foo& lhs, const foo& rhs)
  {
    return lhs.data == rhs.data;
  }
  // Tells whether the argument is value-initialized.
  bool is_value_initialized(const foo& arg)
  {
    return arg.data == 0;
  }
  template <class T>
  void test_key_value_pair(const T& magic_value)
  {
    // The value component of a default key_value_pair must be value-initialized.
    key_value_pair<T> default_key_value_pair;
    BOOST_TEST( is_value_initialized(default_key_value_pair.get_value() ) );
    // The value component of a key_value_pair that only has its key explicitly specified
    // must also be value-initialized.
    BOOST_TEST( is_value_initialized(key_value_pair<T>("key").get_value()) );
    // However, the value component of the following key_value_pair must be 
    // "magic_value", as it must be direct-initialized.
    BOOST_TEST( key_value_pair<T>("key", magic_value).get_value() == magic_value );
  }
 }
 // Tests boost::initialize for a fundamental type, a type with a
 // user-defined constructor, and a user-defined type without 
 // a user-defined constructor.
 int main()
 {
  const int magic_number = 42;
  test_key_value_pair(magic_number);
  const std::string magic_string = "magic value";
  test_key_value_pair(magic_string);
  const foo magic_foo = { 42 };
  test_key_value_pair(magic_foo);
  return boost::report_errors();
 }
--- a/initialized_test_fail1.cpp
+++ b/initialized_test_fail1.cpp
@ -0,0 +1,33 @@
 // Copyright 2010, Niels Dekker.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // Test program for boost::initialized<T>. Must fail to compile.
 //
 // Initial: 2 May 2010
 #include <boost/utility/value_init.hpp>
 namespace
 {
  void direct_initialize_from_int()
  {
    // Okay: initialized<T> supports direct-initialization from T.
    boost::initialized<int> direct_initialized_int(1);
  }
  void copy_initialize_from_int()
  {
    // The following line should not compile, because initialized<T> 
    // was not intended to supports copy-initialization from T.
    boost::initialized<int> copy_initialized_int = 1;
  }
 }
 int main()
 {
  // This should fail to compile, so there is no need to call any function.
  return 0;
 }
--- a/initialized_test_fail2.cpp
+++ b/initialized_test_fail2.cpp
@ -0,0 +1,37 @@
 // Copyright 2010, Niels Dekker.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // Test program for boost::initialized<T>. Must fail to compile.
 //
 // Initial: 2 May 2010
 #include <boost/utility/value_init.hpp>
 namespace
 {
  void from_value_initialized_to_initialized()
  {
    boost::value_initialized<int> value_initialized_int;
    // Okay: initialized<T> can be initialized by value_initialized<T>.
    boost::initialized<int> initialized_int(value_initialized_int);
  }
  void from_initialized_to_value_initialized()
  {
    boost::initialized<int> initialized_int(13);
    // The following line should not compile, because initialized<T>
    // should not be convertible to value_initialized<T>.
    boost::value_initialized<int> value_initialized_int(initialized_int);
  }
 }
 int main()
 {
  // This should fail to compile, so there is no need to call any function.
  return 0;
 }
--- a/iter_adaptor_fail_expected1.cpp
+++ b/iter_adaptor_fail_expected1.cpp
@ -1,27 +0,0 @@
 //  Test boost/pending/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.
 //  See http://www.boost.org for most recent version including documentation.
 // Revision History
 // 21 Jan 01 Initial version (Jeremy Siek)
 #include <boost/config.hpp>
 #include <list>
 #include <boost/pending/iterator_adaptors.hpp>
 int main()
 {
  typedef boost::iterator_adaptor<std::list<int>::iterator,
    boost::default_iterator_policies,
    int,int&,int*,std::bidirectional_iterator_tag> adaptor_type;
  adaptor_type i;
  i += 4;
  return 0;
 }
--- a/iter_adaptor_fail_expected2.cpp
+++ b/iter_adaptor_fail_expected2.cpp
@ -1,28 +0,0 @@
 //  Test boost/pending/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.
 //  See http://www.boost.org for most recent version including documentation.
 // Revision History
 // 21 Jan 01 Initial version (Jeremy Siek)
 #include <boost/config.hpp>
 #include <iostream>
 #include <iterator>
 #include <boost/pending/iterator_adaptors.hpp>
 int main()
 {
  typedef boost::iterator_adaptor<std::istream_iterator<int>,
    boost::default_iterator_policies,
    int,int&,int*,std::input_iterator_tag> adaptor_type;
  adaptor_type iter;
  --iter;
  return 0;
 }
--- a/iter_traits_gen_test.cpp
+++ b/iter_traits_gen_test.cpp
@ -1,61 +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.
 // 04 Nov 2001   Jeremy Siek
 //     Updated with respect to new named parameter interface.
 // 08 Mar 2001   Jeremy Siek
 //     Initial checkin.
 #include <boost/iterator_adaptors.hpp>
 #include <boost/pending/iterator_tests.hpp>
 #include <boost/static_assert.hpp>
 class bar { };
 void foo(bar) { }
 int
 main()
 {
  using boost::dummyT;
  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
                     dummyT(3), dummyT(4), dummyT(5) };
  typedef boost::iterator_adaptor<dummyT*, 
    boost::default_iterator_policies, dummyT> my_iter;
  my_iter mi(array);
  {
    typedef boost::iterator_adaptor<my_iter, boost::default_iterator_policies,
      boost::reference_is<dummyT>,
      boost::iterator_category_is<std::input_iterator_tag> > iter_type;
    BOOST_STATIC_ASSERT((boost::is_same<iter_type::iterator_category*,
       std::input_iterator_tag*>::value));
    BOOST_STATIC_ASSERT(( ! boost::is_convertible<iter_type::iterator_category*,
       std::forward_iterator_tag*>::value));
    iter_type i(mi);
    boost::input_iterator_test(i, dummyT(0), dummyT(1));
  }
  {
    typedef boost::iterator_adaptor<dummyT*,
      boost::default_iterator_policies,
      boost::value_type_is<dummyT>,
      boost::reference_is<const dummyT&>,
      boost::pointer_is<const dummyT*> ,
      boost::iterator_category_is<std::forward_iterator_tag>,
      boost::difference_type_is<std::ptrdiff_t> > adaptor_type;
    adaptor_type i(array);
    boost::input_iterator_test(i, dummyT(0), dummyT(1));
    int zero = 0;
    if (zero) // don't do this, just make sure it compiles
      assert((*i).m_x == i->foo());      
  }
  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_adaptors.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_generator<Function, int* 
  >::type 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_adaptor_test.cpp
+++ b/iterator_adaptor_test.cpp
@ -1,449 +0,0 @@
 //  Test 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.
 //  See http://www.boost.org for most recent version including documentation.
 //  Revision History
 //  30 Nov 01 Added permutation_iterator.(Toon Knapen)
 //  19 Nov 01 Added generator_iterator.  (Jens Maurer)
 //  04 Nov 01 Updated with respect to change in named parameters.
 //            (Jeremy Siek)
 //  08 Mar 01 Moved indirect and transform tests to separate files.
 //            (Jeremy Siek)
 //  19 Feb 01 Take adavantage of improved iterator_traits to do more tests
 //            on MSVC. Hack around an MSVC-with-STLport internal compiler
 //            error. (David Abrahams)
 //  11 Feb 01 Added test of operator-> for forward and input iterators.
 //            (Jeremy Siek)
 //  11 Feb 01 Borland fixes (David Abrahams)
 //  10 Feb 01 Use new adaptors interface. (David Abrahams)
 //  10 Feb 01 Use new filter_ interface. (David Abrahams)
 //  09 Feb 01 Use new reverse_ and indirect_ interfaces. Replace
 //            BOOST_NO_STD_ITERATOR_TRAITS with
 //            BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION to prove we've
 //            normalized to core compiler capabilities (David Abrahams)
 //  08 Feb 01 Use Jeremy's new make_reverse_iterator form; add more
 //            comprehensive testing. Force-decay array function arguments to
 //            pointers.
 //  07 Feb 01 Added tests for the make_xxx_iterator() helper functions.
 //            (Jeremy Siek)
 //  07 Feb 01 Replaced use of xxx_pair_generator with xxx_generator where
 //            possible (which was all but the projection iterator).
 //            (Jeremy Siek)
 //  06 Feb 01 Removed now-defaulted template arguments where possible
 //            Updated names to correspond to new generator naming convention.
 //            Added a trivial test for make_transform_iterator().
 //            Gave traits for const iterators a mutable value_type, per std.
 //            Resurrected my original tests for indirect iterators.
 //            (David Abrahams)
 //  04 Feb 01 Fix for compilers without standard iterator_traits
 //            (David Abrahams)
 //  13 Jun 00 Added const version of the iterator tests (Jeremy Siek)
 //  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
 #include <boost/config.hpp>
 #include <iostream>
 #include <algorithm>
 #include <functional>
 #include <numeric>
 #include <boost/iterator_adaptors.hpp>
 #include <boost/generator_iterator.hpp>
 #include <boost/pending/iterator_tests.hpp>
 #include <boost/pending/integer_range.hpp>
 #include <boost/concept_archetype.hpp>
 #include <boost/type_traits/same_traits.hpp>
 #include <boost/permutation_iterator.hpp>
 #include <stdlib.h>
 #include <vector>
 #include <deque>
 #include <set>
 #include <list>
 struct my_iterator_tag : public std::random_access_iterator_tag { };
 using boost::dummyT;
 struct mult_functor {
  typedef int result_type;
  typedef int argument_type;
  // Functors used with transform_iterator must be
  // DefaultConstructible, as the transform_iterator must be
  // DefaultConstructible to satisfy the requirements for
  // TrivialIterator.
  mult_functor() { }
  mult_functor(int aa) : a(aa) { }
  int operator()(int b) const { return a * b; }
  int a;
 };
 template <class Pair>
 struct select1st_ 
  : public std::unary_function<Pair, typename Pair::first_type>
 {
  const typename Pair::first_type& operator()(const Pair& x) const {
    return x.first;
  }
  typename Pair::first_type& operator()(Pair& x) const {
    return x.first;
  }
 };
 struct one_or_four {
  bool operator()(dummyT x) const {
    return x.foo() == 1 || x.foo() == 4;
  }
 };
 typedef std::deque<int> storage;
 typedef std::deque<int*> pointer_deque;
 typedef std::set<storage::iterator> iterator_set;
 template <class T> struct foo;
 void blah(int) { }
 struct my_gen
 {
  typedef int result_type;
  my_gen() : n(0) { }
  int operator()() { return ++n; }
  int n;
 };
 int
 main()
 {
  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
                     dummyT(3), dummyT(4), dummyT(5) };
  const int N = sizeof(array)/sizeof(dummyT);
  // sanity check, if this doesn't pass the test is buggy
  boost::random_access_iterator_test(array, N, array);
  // Check that the policy concept checks and the default policy
  // implementation match up.
  boost::function_requires< 
     boost::RandomAccessIteratorPoliciesConcept<
       boost::default_iterator_policies,
       boost::iterator_adaptor<storage::iterator, boost::default_iterator_policies>,
       boost::iterator<std::random_access_iterator_tag, int, std::ptrdiff_t,
                      int*, int&>
      > >();
  // Test the named parameters
  {
    // Test computation of defaults
    typedef boost::iterator_adaptor<int*, boost::default_iterator_policies,
      boost::value_type_is<int> > Iter1;
    // don't use std::iterator_traits here to avoid VC++ problems
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::value_type, int>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, int&>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, int*>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::difference_type, std::ptrdiff_t>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::iterator_category, std::random_access_iterator_tag>::value));
  }
  {  
    // Test computation of default when the Value is const
    typedef boost::iterator_adaptor<std::list<int>::iterator,
      boost::default_iterator_policies,
      boost::value_type_is<const int> > Iter1;
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::value_type, int>::value));
 #if defined(__BORLANDC__) || defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    // We currently don't know how to workaround this bug.
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, int&>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, int*>::value));
 #else
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, const int&>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, const int*>::value));
 #endif
  }
  {
    // Test with no defaults
    typedef boost::iterator_adaptor<int*, boost::default_iterator_policies,
      boost::reference_is<long>,
      boost::pointer_is<float*>,
      boost::value_type_is<char>,
      boost::iterator_category_is<std::input_iterator_tag>,
      boost::difference_type_is<int>
    > Iter1;
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::value_type, char>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, long>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, float*>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::difference_type, int>::value));
    BOOST_STATIC_ASSERT((boost::is_same<Iter1::iterator_category, std::input_iterator_tag>::value));
  }
  // Test the iterator_adaptor
  {
    boost::iterator_adaptor<dummyT*, boost::default_iterator_policies, dummyT> i(array);
    boost::random_access_iterator_test(i, N, array);
    boost::iterator_adaptor<const dummyT*, boost::default_iterator_policies, const dummyT> j(array);
    boost::random_access_iterator_test(j, N, array);
    boost::const_nonconst_iterator_test(i, ++j);
  }
  // Test projection_iterator_pair_generator
  {    
    typedef std::pair<dummyT,dummyT> Pair;
    Pair pair_array[N];
    for (int k = 0; k < N; ++k)
      pair_array[k].first = array[k];
    typedef boost::projection_iterator_pair_generator<select1st_<Pair>,
      Pair*, const Pair*
      > Projection;
    Projection::iterator i(pair_array);
    boost::random_access_iterator_test(i, N, array);
    boost::random_access_iterator_test(boost::make_projection_iterator(pair_array, select1st_<Pair>()), N, array);    
    boost::random_access_iterator_test(boost::make_projection_iterator< select1st_<Pair> >(pair_array), N, array);    
    Projection::const_iterator j(pair_array);
    boost::random_access_iterator_test(j, N, array);
    boost::random_access_iterator_test(boost::make_const_projection_iterator(pair_array, select1st_<Pair>()), N, array);
    boost::random_access_iterator_test(boost::make_const_projection_iterator<select1st_<Pair> >(pair_array), N, array);
    boost::const_nonconst_iterator_test(i, ++j);
  }
  // Test reverse_iterator_generator
  {
    dummyT reversed[N];
    std::copy(array, array + N, reversed);
    std::reverse(reversed, reversed + N);
    typedef boost::reverse_iterator_generator<dummyT*
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_STD_ITERATOR_TRAITS)
        , dummyT
 #endif
      >::type reverse_iterator;
    reverse_iterator i(reversed + N);
    boost::random_access_iterator_test(i, N, array);
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
 #endif
    typedef boost::reverse_iterator_generator<const dummyT*
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_STD_ITERATOR_TRAITS)
      , dummyT, const dummyT&, const dummyT
 #endif
      >::type const_reverse_iterator;
    const_reverse_iterator j(reversed + N);
    boost::random_access_iterator_test(j, N, array);
    const dummyT* const_reversed = reversed;
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
 #endif
    boost::const_nonconst_iterator_test(i, ++j);    
  }
  // Test reverse_iterator_generator again, with traits fully deducible on all platforms
  {
    std::deque<dummyT> reversed_container;
    std::reverse_copy(array, array + N, std::back_inserter(reversed_container));
    const std::deque<dummyT>::iterator reversed = reversed_container.begin();
    typedef boost::reverse_iterator_generator<
        std::deque<dummyT>::iterator>::type reverse_iterator;
    typedef boost::reverse_iterator_generator<
        std::deque<dummyT>::const_iterator, const dummyT>::type const_reverse_iterator;
    // MSVC/STLport gives an INTERNAL COMPILER ERROR when any computation
    // (e.g. "reversed + N") is used in the constructor below.
    const std::deque<dummyT>::iterator finish = reversed_container.end();
    reverse_iterator i(finish);
    boost::random_access_iterator_test(i, N, array);
    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
    const_reverse_iterator j = reverse_iterator(finish);
    boost::random_access_iterator_test(j, N, array);
    const std::deque<dummyT>::const_iterator const_reversed = reversed;
    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
    // Many compilers' builtin deque iterators don't interoperate well, though
    // STLport fixes that problem.
 #if defined(__SGI_STL_PORT) || !defined(__GNUC__) && !defined(__BORLANDC__) && (!defined(BOOST_MSVC) || BOOST_MSVC > 1200)
    boost::const_nonconst_iterator_test(i, ++j);
 #endif
  }
  // Test integer_range's iterators
  {
    int int_array[] = { 0, 1, 2, 3, 4, 5 };
    boost::integer_range<int> r(0, 5);
    boost::random_access_iterator_test(r.begin(), r.size(), int_array);
  }
  // Test filter iterator
  {
    // Using typedefs for filter_gen::type confused Borland terribly.
    typedef boost::detail::non_bidirectional_category<dummyT*>::type category;
    typedef boost::filter_iterator_generator<one_or_four, dummyT*
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_STD_ITERATOR_TRAITS)
        , dummyT
 #endif
        >::type filter_iter;
 #if defined(__BORLANDC__)
    // Borland is choking on accessing the policies_type explicitly
    // from the filter_iter. 
    boost::forward_iterator_test(make_filter_iterator(array, array+N, 
                                                      one_or_four()),
                                 dummyT(1), dummyT(4));
 #else
    filter_iter i(array, filter_iter::policies_type(one_or_four(), array + N));
    boost::forward_iterator_test(i, dummyT(1), dummyT(4));
 #endif
 #if !defined(__BORLANDC__)
    // 
    enum { is_forward = boost::is_same<
           filter_iter::iterator_category,
           std::forward_iterator_tag>::value };
    BOOST_STATIC_ASSERT(is_forward);
 #endif
    // On compilers not supporting partial specialization, we can do more type
    // deduction with deque iterators than with pointers... unless the library
    // is broken ;-(
 #if !defined(BOOST_MSVC) || BOOST_MSVC > 1200 || defined(__SGI_STL_PORT)
    std::deque<dummyT> array2;
    std::copy(array+0, array+N, std::back_inserter(array2));
    boost::forward_iterator_test(
        boost::make_filter_iterator(array2.begin(), array2.end(), one_or_four()),
        dummyT(1), dummyT(4));
    boost::forward_iterator_test(
        boost::make_filter_iterator<one_or_four>(array2.begin(), array2.end()),
        dummyT(1), dummyT(4));
 #endif
 #if !defined(BOOST_MSVC) || BOOST_MSVC > 1200 // This just freaks MSVC out completely
    boost::forward_iterator_test(
        boost::make_filter_iterator<one_or_four>(
            boost::make_reverse_iterator(array2.end()),
            boost::make_reverse_iterator(array2.begin())
            ),
        dummyT(4), dummyT(1));
 #endif
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
    boost::forward_iterator_test(
        boost::make_filter_iterator(array+0, array+N, one_or_four()),
        dummyT(1), dummyT(4));
    boost::forward_iterator_test(
        boost::make_filter_iterator<one_or_four>(array, array + N),
        dummyT(1), dummyT(4));
 #endif
  }
  // check operator-> with a forward iterator
  {
    boost::forward_iterator_archetype<dummyT> forward_iter;
 #if defined(__BORLANDC__)
    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
      boost::default_iterator_policies,
      dummyT, const dummyT&, const dummyT*, 
      std::forward_iterator_tag, std::ptrdiff_t> adaptor_type;
 #else
    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
      boost::default_iterator_policies,
      boost::reference_is<const dummyT&>,
      boost::pointer_is<const dummyT*> ,
      boost::iterator_category_is<std::forward_iterator_tag>,
      boost::value_type_is<dummyT>,
      boost::difference_type_is<std::ptrdiff_t>
    > adaptor_type;
 #endif
    adaptor_type i(forward_iter);
    int zero = 0;
    if (zero) // don't do this, just make sure it compiles
      assert((*i).m_x == i->foo());      
  }
  // check operator-> with an input iterator
  {
    boost::input_iterator_archetype<dummyT> input_iter;
    typedef boost::iterator_adaptor<boost::input_iterator_archetype<dummyT>,
      boost::default_iterator_policies,
      dummyT, const dummyT&, const dummyT*, 
      std::input_iterator_tag, std::ptrdiff_t> adaptor_type;
    adaptor_type i(input_iter);
    int zero = 0;
    if (zero) // don't do this, just make sure it compiles
      assert((*i).m_x == i->foo());      
  }
  {
    // check generator_iterator
    my_gen g1;
    boost::generator_iterator_generator<my_gen>::type gen =
      boost::make_generator_iterator(g1);
    assert(*gen == 1);
    ++gen;
    gen++;
    assert(*gen == 3);
  }
  {
    // check permutation_iterator
    typedef std::deque< int > element_range_type;
    typedef std::list< int > index_type;
    static const int element_range_size = 10;
    static const int index_size = 4;
    element_range_type elements( element_range_size );
    for(element_range_type::iterator el_it = elements.begin();
        el_it != elements.end();
        ++el_it)
    {
        *el_it = std::distance( elements.begin(), el_it );
    }
    index_type indices( index_size );
    for(index_type::iterator i_it = indices.begin();
        i_it != indices.end();
        ++i_it)
    {
        *i_it = element_range_size - index_size
            + std::distance(indices.begin(), i_it );
    }
    std::reverse( indices.begin(), indices.end() );
    typedef boost::permutation_iterator_generator< element_range_type::iterator, index_type::iterator >::type permutation_type;
    permutation_type begin = boost::make_permutation_iterator( elements.begin(), indices.begin() );
    permutation_type end = boost::make_permutation_iterator( elements.begin(), indices.end() );
    int expected_outcome[] = { 9, 8, 7, 6 };
    assert( std::equal( begin, end, expected_outcome ) );
  }
  std::cout << "test successful " << std::endl;
  return 0;
 }
--- a/iterator_adaptors.htm
+++ b/iterator_adaptors.htm
--- a/iterator_adaptors.pdf
+++ b/iterator_adaptors.pdf
--- a/iterator_adaptors.ppt
+++ b/iterator_adaptors.ppt
--- a/iterator_traits_test.cpp
+++ b/iterator_traits_test.cpp
@ -1,215 +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
 //  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.hpp>
 #include <boost/operators.hpp>
 #include <boost/static_assert.hpp>
 #include <iterator>
 #include <vector>
 #include <list>
 #include <cassert>
 #include <iostream>
 // 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) {}
 };
 template <class Iterator,
    class value_type, class difference_type, class pointer, class reference, class category>
 struct non_portable_tests
 {
    // Unfortunately, the VC6 standard library doesn't supply these :(
    typedef typename boost::detail::iterator_traits<Iterator>::pointer test_pt;
    typedef typename boost::detail::iterator_traits<Iterator>::reference test_rt;
    BOOST_STATIC_ASSERT((
        ::boost::is_same<
        test_pt,
        pointer
        >::value));
    BOOST_STATIC_ASSERT((
        ::boost::is_same<
        test_rt,
        reference
        >::value));
 };
 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;
    BOOST_STATIC_ASSERT((
        ::boost::is_same<
        test_dt,
        difference_type
        >::value));
    BOOST_STATIC_ASSERT((
        ::boost::is_same<
        test_cat,
        category
        >::value));
 };
 // 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;
    BOOST_STATIC_ASSERT((
        ::boost::is_same<
        test_vt,
        value_type
        >::value));
 };
 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>
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
      , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
 #endif
 {
 };
 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, void, void, 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 (std::ptrdiff_t 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,
+//  (C) Copyright Jeremy Siek 1999.
-//  sell and distribute this software is granted provided this
+// Distributed under the Boost Software License, Version 1.0. (See
-//  copyright notice appears in all copies. This software is provided
+// accompanying file LICENSE_1_0.txt or copy at
-//  "as is" without express or implied warranty, and with no claim as
+// http://www.boost.org/LICENSE_1_0.txt)
 //  to its suitability for any purpose.
 //  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_CHECK( oss.str() == "apple orange pear peach grape plum ");
    BOOST_TEST( std::strcmp(oss.str(), "apple orange pear peach grape plum ")
     == 0 );
 }
 // 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_CHECK( oss.str() == "plum grape peach pear orange apple ");
    BOOST_TEST( std::strcmp(oss.str(), "plum grape peach pear orange apple ")
     == 0 );
 }
 // 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_CHECK( oss.str() == "5 6 4 5 5 4 ");
    BOOST_TEST( std::strcmp(oss.str(), "5 6 4 5 5 4 ") == 0 );
 }
 // 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_CHECK( oss.str() == "apple pear grape ");
    BOOST_TEST( std::strcmp(oss.str(), "apple pear grape ") == 0 );
 }
 // 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_CHECK( oss.str() == "apple pear grape ");
    BOOST_TEST( std::strcmp(oss.str(), "apple pear grape ") == 0 );
 }
 // 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_CHECK( oss.str() == "grape pear apple ");
    BOOST_TEST( std::strcmp(oss.str(), "grape pear apple ") == 0 );
 }
 // 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_CHECK( (i != j) == (i_offset != j_offset) );
-            BOOST_TEST( (i > j) == (i_offset > j_offset) );
+            BOOST_CHECK( (i > j) == (i_offset > j_offset) );
-            BOOST_TEST( (i <= j) == (i_offset <= j_offset) );
+            BOOST_CHECK( (i <= j) == (i_offset <= j_offset) );
-            BOOST_TEST( (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_CHECK( oss.str() == "apple orange pear peach grape plum ");
    BOOST_TEST( std::strcmp(oss.str(), "apple orange pear peach grape plum ")
     == 0 );
 }
--- 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
+//  (C) Copyright Beman Dawes 1999. Distributed under the Boost
-//  and distribute this software is granted provided this copyright
+//  Software License, Version 1.0. (See accompanying file
-//  notice appears in all copies. This software is provided "as is" without
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //  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.
@ -12,7 +10,7 @@
 //   9 Jun 99  Add unnamed namespace
 //   2 Jun 99  Initial Version
-#include <boost/utility.hpp>
+#include <boost/noncopyable.hpp>
 #include <iostream>
 //  This program demonstrates compiler errors resulting from trying to copy
--- a/numeric_traits_test.cpp
+++ b/numeric_traits_test.cpp
@ -1,8 +1,7 @@
-//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify,
+//  (C) Copyright David Abrahams 2001.
-//  sell and distribute this software is granted provided this
+// Distributed under the Boost Software License, Version 1.0. (See
-//  copyright notice appears in all copies. This software is provided
+// accompanying file LICENSE_1_0.txt or copy at
-//  "as is" without express or implied warranty, and with no claim as
+// http://www.boost.org/LICENSE_1_0.txt)
 //  to its suitability for any purpose.
 //  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
    };
 };
@ -214,7 +221,7 @@ struct signed_tag {};
 // Tests for unsigned numbers. The extra default Number parameter works around
 // an MSVC bug.
 template <class Number>
-void test_aux(unsigned_tag, Number* = 0)
+void test_aux(unsigned_tag, Number*)
 {
    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
    BOOST_STATIC_ASSERT(!boost::detail::is_signed<Number>::value);
@ -222,10 +229,16 @@ void test_aux(unsigned_tag, Number* = 0)
        (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;
@ -256,7 +269,7 @@ struct in_range_tag {};
 // This test morsel gets executed for numbers whose difference will always be
 // representable in intmax_t
 template <class Number>
-void signed_test(in_range_tag, Number* = 0)
+void signed_test(in_range_tag, Number*)
 {
    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
@ -277,7 +290,7 @@ void signed_test(in_range_tag, Number* = 0)
 // This test morsel gets executed for numbers whose difference may exceed the
 // capacity of intmax_t.
 template <class Number>
-void signed_test(out_of_range_tag, Number* = 0)
+void signed_test(out_of_range_tag, Number*)
 {
    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
@ -301,7 +314,7 @@ void signed_test(out_of_range_tag, Number* = 0)
 }
 template <class Number>
-void test_aux(signed_tag, Number* = 0)
+void test_aux(signed_tag, Number*)
 {
    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
@ -309,10 +322,15 @@ void test_aux(signed_tag, Number* = 0)
        (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;
@ -328,7 +346,7 @@ void test_aux(signed_tag, Number* = 0)
                          out_of_range_tag
                        >::type
        range_tag;
-    signed_test<Number>(range_tag());
+    signed_test<Number>(range_tag(), 0);
 }
@ -358,7 +376,7 @@ void test(Number* = 0)
        boost::detail::is_signed<Number>::value
        >::template then<signed_tag, unsigned_tag>::type signedness;
-    test_aux<Number>(signedness());
+    test_aux<Number>(signedness(), 0);
    std::cout << "passed" << std::endl;
 }
@ -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< ::boost::long_long_type>();
-    test<unsigned long long>();
+    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
--- a/operators_test.cpp
+++ b/operators_test.cpp
@ -1,13 +1,13 @@
 //  Demonstrate and test boost/operators.hpp  -------------------------------//
-//  (C) Copyright Beman Dawes 1999. Permission to copy, use, modify, sell and
+//  Copyright Beman Dawes 1999.  Distributed under the Boost
-//  distribute this software is granted provided this copyright notice appears
+//  Software License, Version 1.0. (See accompanying file
-//  in all copies. This software is provided "as is" without express or implied
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //  warranty, and with no claim as to its suitability for any purpose.
-//  See http://www.boost.org for most recent version including documentation.
+//  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
@ -44,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>
@ -55,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; }
+        convertible_to_bool operator<(const Wrapped1& x) const
-        bool operator==(const Wrapped1& x) const { return _value == x._value; }
+          { 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; }
@ -98,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; }
+        convertible_to_bool operator<(const Wrapped2& x) const
-        bool operator==(const Wrapped2& x) const { return _value == x._value; }
+          { 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; }
@ -124,9 +145,13 @@ namespace
        Wrapped2& operator++()                { ++_value; return *this; }
        Wrapped2& operator--()                { --_value; return *this; }
-        bool operator<(U u) const { return _value < u; }
+        convertible_to_bool operator<(U u) const
-        bool operator>(U u) const { return _value > u; }
+          { 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; }
        Wrapped2& operator+=(U u) { _value += u; return *this; }
        Wrapped2& operator-=(U u) { _value -= u; return *this; }
        Wrapped2& operator*=(U u) { _value *= u; return *this; }
@ -154,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;
@ -175,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; }
+        convertible_to_bool operator<(U u) const
-        bool operator>(U u) const { return _value > u; }
+          { return _value < u; }
        convertible_to_bool operator>(U u) const
          { return _value > u; }
    private:
        T _value;
@ -199,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; }
+        convertible_to_bool operator<(const Wrapped5& x) const
-        bool operator>(U u) const { return _value > u; }
+          { return _value < x._value; }
-        bool operator==(const Wrapped5& u) const { return _value == u._value; }
+        convertible_to_bool operator<(U u) const
-        bool operator==(U u) const { return _value == u; }
+          { 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;}
@ -222,8 +258,8 @@ namespace
    // U must be convertible to T
    template <class T, class U>
    class Wrapped6
-        : boost::ordered_euclidian_ring_operators2<Wrapped6<T, U>, U>
+        : boost::ordered_euclidean_ring_operators2<Wrapped6<T, U>, U>
-        , boost::ordered_euclidian_ring_operators1<Wrapped6<T, U> >
+        , boost::ordered_euclidean_ring_operators1<Wrapped6<T, U> >
    {
    public:
        explicit Wrapped6( T v = T() ) : _value(v) {}
@ -232,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; }
+        convertible_to_bool operator<(const Wrapped6& x) const
-        bool operator>(U u) const { return _value > u; }
+          { return _value < x._value; }
-        bool operator==(const Wrapped6& u) const { return _value == u._value; }
+        convertible_to_bool operator<(U u) const
-        bool operator==(U u) const { return _value == u; }
+          { 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;}
@ -270,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_CHECK( true_value(y1) == true_value(y2) );
-        BOOST_TEST( true_value(x1) == true_value(x2) );
+        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_CHECK( static_cast<bool>(x1 < y1) == static_cast<bool>(x2 < y2) );
-        BOOST_TEST( (x1 <= y1) == (x2 <= y2) );
+        BOOST_CHECK( static_cast<bool>(x1 <= y1) == static_cast<bool>(x2 <= y2) );
-        BOOST_TEST( (x1 >= y1) == (x2 >= y2) );
+        BOOST_CHECK( static_cast<bool>(x1 >= y1) == static_cast<bool>(x2 >= y2) );
-        BOOST_TEST( (x1 > y1) == (x2 > y2) );
+        BOOST_CHECK( static_cast<bool>(x1 > y1) == static_cast<bool>(x2 > y2) );
    }
    template <class X1, class Y1, class X2, class Y2>
@ -294,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_CHECK( static_cast<bool>(x1 == y1) == static_cast<bool>(x2 == y2) );
-        BOOST_TEST( (x1 != y1) == (x2 != y2) );
+        BOOST_CHECK( static_cast<bool>(x1 != y1) == static_cast<bool>(x2 != y2) );
    }
    template <class X1, class Y1, class X2, class Y2>
@ -309,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>
@ -319,11 +362,20 @@ namespace
        test_multipliable_aux( x1, y1, x2, y2 );
        test_multipliable_aux( y1, x1, y2, x2 );
    }
-    
+
  template <class A, class B>
  void test_value_equality(A a, B b)
  {
      BOOST_CHECK(a.value() == b);
  }
 #define TEST_OP_R(op) test_value_equality(x1 op y1, x2 op y2)
 #define TEST_OP_L(op) test_value_equality(y1 op x1, y2 op x2)
    template <class X1, class Y1, class X2, class Y2>
    void test_addable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        BOOST_TEST( (x1 + y1).value() == (x2 + y2) );
+        TEST_OP_R(+);
    }
    template <class X1, class Y1, class X2, class Y2>
@ -333,19 +385,19 @@ namespace
        test_addable_aux( x1, y1, x2, y2 );
        test_addable_aux( y1, x1, y2, x2 );
    }
-    
+
    template <class X1, class Y1, class X2, class Y2>
    void test_subtractable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
        sanity_check( x1, y1, x2, y2 );
-        BOOST_TEST( (x1 - y1).value() == (x2 - y2) );
+        TEST_OP_R(-);
    }
    template <class X1, class Y1, class X2, class Y2>
    void test_subtractable_left(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
        sanity_check( x1, y1, x2, y2 );
-        BOOST_TEST( (y1 - x1).value() == (y2 - x2) );
+        TEST_OP_L(-);
    }
    template <class X1, class Y1, class X2, class Y2>
@ -353,7 +405,7 @@ namespace
    {
        sanity_check( x1, y1, x2, y2 );
        if ( y2 != 0 )
-            BOOST_TEST( (x1 / y1).value() == (x2 / y2) );
+            TEST_OP_R(/);
    }
    template <class X1, class Y1, class X2, class Y2>
@ -361,7 +413,7 @@ namespace
    {
        sanity_check( x1, y1, x2, y2 );
        if ( x2 != 0 )
-            BOOST_TEST( (y1 / x1).value() == (y2 / x2) );
+            TEST_OP_L(/);
    }
    template <class X1, class Y1, class X2, class Y2>
@ -369,7 +421,7 @@ namespace
    {
        sanity_check( x1, y1, x2, y2 );
        if ( y2 != 0 )
-            BOOST_TEST( (x1 % y1).value() == (x2 % y2) );
+            TEST_OP_R(%);
    }
    template <class X1, class Y1, class X2, class Y2>
@ -377,13 +429,13 @@ namespace
    {
        sanity_check( x1, y1, x2, y2 );
        if ( x2 != 0 )
-            BOOST_TEST( (y1 % x1).value() == (y2 % x2) );
+            TEST_OP_L(%);
    }
    template <class X1, class Y1, class X2, class Y2>
    void test_xorable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        BOOST_TEST( (x1 ^ y1).value() == (x2 ^ y2) );
+        TEST_OP_R(^);
    }
    template <class X1, class Y1, class X2, class Y2>
@ -397,7 +449,7 @@ namespace
    template <class X1, class Y1, class X2, class Y2>
    void test_andable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        BOOST_TEST( (x1 & y1).value() == (x2 & y2) );
+        TEST_OP_R(&);
    }
    template <class X1, class Y1, class X2, class Y2>
@ -411,7 +463,7 @@ namespace
    template <class X1, class Y1, class X2, class Y2>
    void test_orable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        BOOST_TEST( (x1 | y1).value() == (x2 | y2) );
+        TEST_OP_R(|);
    }
    template <class X1, class Y1, class X2, class Y2>
@ -426,30 +478,30 @@ namespace
    void test_left_shiftable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
        sanity_check( x1, y1, x2, y2 );
-        BOOST_TEST( (x1 << y1).value() == (x2 << y2) );
+        TEST_OP_R(<<);
    }
    template <class X1, class Y1, class X2, class Y2>
    void test_right_shiftable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
        sanity_check( x1, y1, x2, y2 );
-        BOOST_TEST( (x1 >> y1).value() == (x2 >> y2) );
+        TEST_OP_R(>>);
    }
    template <class X1, class X2>
    void test_incrementable(X1 x1, X2 x2)
    {
        sanity_check( x1, x1, x2, x2 );
-        BOOST_TEST( (x1++).value() == x2++ );
+        BOOST_CHECK( (x1++).value() == x2++ );
-        BOOST_TEST( 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_CHECK( (x1--).value() == x2-- );
-        BOOST_TEST( x1.value() == x2 );
+        BOOST_CHECK( x1.value() == x2 );
    }
    template <class X1, class Y1, class X2, class Y2>
@ -528,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>;
@ -553,8 +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 * [] )
@ -569,7 +620,7 @@ test_main( int , char * [] )
    cout << "Created point, and operated on it." << endl;
-    for (int n = 0; n < 10000; ++n)
+    for (int n = 0; n < 1000; ++n)  // was 10,000 but took too long (Beman)
    {
        boost::minstd_rand r;
        tester<long, int>()(r);
@ -599,22 +650,22 @@ test_main( int , char * [] )
    MyInt i2(2);
    MyInt i;
-    BOOST_TEST( i1.value() == 1 );
+    BOOST_CHECK( i1.value() == 1 );
-    BOOST_TEST( i2.value() == 2 );
+    BOOST_CHECK( i2.value() == 2 );
-    BOOST_TEST( i.value() == 0 );
+    BOOST_CHECK( i.value() == 0 );
    cout << "Created MyInt objects.\n";
    PRIVATE_EXPR_TEST( (i = i2), (i.value() == 2) );
-    BOOST_TEST( i2 == i );
+    BOOST_CHECK( static_cast<bool>(i2 == i) );
-    BOOST_TEST( i1 != i2 );
+    BOOST_CHECK( static_cast<bool>(i1 != i2) );
-    BOOST_TEST( i1 <  i2 );
+    BOOST_CHECK( static_cast<bool>(i1 <  i2) );
-    BOOST_TEST( i1 <= i2 );
+    BOOST_CHECK( static_cast<bool>(i1 <= i2) );
-    BOOST_TEST( i <= i2 );
+    BOOST_CHECK( static_cast<bool>(i <= i2) );
-    BOOST_TEST( i2 >  i1 );
+    BOOST_CHECK( static_cast<bool>(i2 >  i1) );
-    BOOST_TEST( i2 >= i1 );
+    BOOST_CHECK( static_cast<bool>(i2 >= i1) );
-    BOOST_TEST( i2 >= i );
+    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) );
@ -631,93 +682,93 @@ test_main( int , char * [] )
    PRIVATE_EXPR_TEST( (i = i1 << i2), (i.value() == 4) );
    PRIVATE_EXPR_TEST( (i = i2 >> i1), (i.value() == 1) );
-    
+
    cout << "Performed tests on MyInt objects.\n";
    MyLong j1(1);
    MyLong j2(2);
    MyLong j;
-    BOOST_TEST( j1.value() == 1 );
+    BOOST_CHECK( j1.value() == 1 );
-    BOOST_TEST( j2.value() == 2 );
+    BOOST_CHECK( j2.value() == 2 );
-    BOOST_TEST( j.value() == 0 );
+    BOOST_CHECK( j.value() == 0 );
    cout << "Created MyLong objects.\n";
    PRIVATE_EXPR_TEST( (j = j2), (j.value() == 2) );
-    BOOST_TEST( j2 == j );
+    BOOST_CHECK( static_cast<bool>(j2 == j) );
-    BOOST_TEST( 2 == j );
+    BOOST_CHECK( static_cast<bool>(2 == j) );
-    BOOST_TEST( j2 == 2 );    
+    BOOST_CHECK( static_cast<bool>(j2 == 2) );
-    BOOST_TEST( j == j2 );
+    BOOST_CHECK( static_cast<bool>(j == j2) );
-    BOOST_TEST( j1 != j2 );
+    BOOST_CHECK( static_cast<bool>(j1 != j2) );
-    BOOST_TEST( j1 != 2 );
+    BOOST_CHECK( static_cast<bool>(j1 != 2) );
-    BOOST_TEST( 1 != j2 );
+    BOOST_CHECK( static_cast<bool>(1 != j2) );
-    BOOST_TEST( j1 <  j2 );
+    BOOST_CHECK( static_cast<bool>(j1 <  j2) );
-    BOOST_TEST( 1 <  j2 );
+    BOOST_CHECK( static_cast<bool>(1 <  j2) );
-    BOOST_TEST( j1 <  2 );
+    BOOST_CHECK( static_cast<bool>(j1 <  2) );
-    BOOST_TEST( j1 <= j2 );
+    BOOST_CHECK( static_cast<bool>(j1 <= j2) );
-    BOOST_TEST( 1 <= j2 );
+    BOOST_CHECK( static_cast<bool>(1 <= j2) );
-    BOOST_TEST( j1 <= j );
+    BOOST_CHECK( static_cast<bool>(j1 <= j) );
-    BOOST_TEST( j <= j2 );
+    BOOST_CHECK( static_cast<bool>(j <= j2) );
-    BOOST_TEST( 2 <= j2 );
+    BOOST_CHECK( static_cast<bool>(2 <= j2) );
-    BOOST_TEST( j <= 2 );
+    BOOST_CHECK( static_cast<bool>(j <= 2) );
-    BOOST_TEST( j2 >  j1 );
+    BOOST_CHECK( static_cast<bool>(j2 >  j1) );
-    BOOST_TEST( 2 >  j1 );
+    BOOST_CHECK( static_cast<bool>(2 >  j1) );
-    BOOST_TEST( j2 >  1 );
+    BOOST_CHECK( static_cast<bool>(j2 >  1) );
-    BOOST_TEST( j2 >= j1 );
+    BOOST_CHECK( static_cast<bool>(j2 >= j1) );
-    BOOST_TEST( 2 >= j1 );
+    BOOST_CHECK( static_cast<bool>(2 >= j1) );
-    BOOST_TEST( j2 >= 1 );
+    BOOST_CHECK( static_cast<bool>(j2 >= 1) );
-    BOOST_TEST( j2 >= j );
+    BOOST_CHECK( static_cast<bool>(j2 >= j) );
-    BOOST_TEST( 2 >= j );
+    BOOST_CHECK( static_cast<bool>(2 >= j) );
-    BOOST_TEST( j2 >= 2 );
+    BOOST_CHECK( static_cast<bool>(j2 >= 2) );
-    BOOST_TEST( (j1 + 2) == 3 );
+    BOOST_CHECK( static_cast<bool>((j1 + 2) == 3) );
-    BOOST_TEST( (1 + j2) == 3 );
+    BOOST_CHECK( static_cast<bool>((1 + j2) == 3) );
    PRIVATE_EXPR_TEST( (j = j1 + j2), (j.value() == 3) );
-    BOOST_TEST( (j + 2) == 5 );
+    BOOST_CHECK( static_cast<bool>((j + 2) == 5) );
-    BOOST_TEST( (3 + j2) == 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_CHECK( static_cast<bool>((j * 2) == 8) );
-    BOOST_TEST( (4 * j2) == 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_CHECK( static_cast<bool>((1 | j2 | j) == 7) );
-    BOOST_TEST( (j1 | 2 | j) == 7 );
+    BOOST_CHECK( static_cast<bool>((j1 | 2 | j) == 7) );
-    BOOST_TEST( (j1 | j2 | 4) == 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_CHECK( static_cast<bool>((7 & j2) == 2) );
-    BOOST_TEST( (j & 2) == 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_CHECK( static_cast<bool>((3 ^ j1) == 2) );
-    BOOST_TEST( (j ^ 1) == 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_CHECK( static_cast<bool>((j1 << 2) == 4) );
-    BOOST_TEST( (j2 << 1) == 4 );
+    BOOST_CHECK( static_cast<bool>((j2 << 1) == 4) );
    PRIVATE_EXPR_TEST( (j = j1 << j2), (j.value() == 4) );
-    BOOST_TEST( (j >> 2) == 1 );
+    BOOST_CHECK( static_cast<bool>((j >> 2) == 1) );
-    BOOST_TEST( (j2 >> 1) == 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";
@ -726,22 +777,22 @@ test_main( int , char * [] )
    MyChar k2(2);
    MyChar k;
-    BOOST_TEST( k1.value() == 1 );
+    BOOST_CHECK( k1.value() == 1 );
-    BOOST_TEST( k2.value() == 2 );
+    BOOST_CHECK( k2.value() == 2 );
-    BOOST_TEST( k.value() == 0 );
+    BOOST_CHECK( k.value() == 0 );
    cout << "Created MyChar objects.\n";
    PRIVATE_EXPR_TEST( (k = k2), (k.value() == 2) );
-    BOOST_TEST( k2 == k );
+    BOOST_CHECK( static_cast<bool>(k2 == k) );
-    BOOST_TEST( k1 != k2 );
+    BOOST_CHECK( static_cast<bool>(k1 != k2) );
-    BOOST_TEST( k1 <  k2 );
+    BOOST_CHECK( static_cast<bool>(k1 <  k2) );
-    BOOST_TEST( k1 <= k2 );
+    BOOST_CHECK( static_cast<bool>(k1 <= k2) );
-    BOOST_TEST( k <= k2 );
+    BOOST_CHECK( static_cast<bool>(k <= k2) );
-    BOOST_TEST( k2 >  k1 );
+    BOOST_CHECK( static_cast<bool>(k2 >  k1) );
-    BOOST_TEST( k2 >= k1 );
+    BOOST_CHECK( static_cast<bool>(k2 >= k1) );
-    BOOST_TEST( k2 >= k );
+    BOOST_CHECK( static_cast<bool>(k2 >= k) );
    cout << "Performed tests on MyChar objects.\n";
@ -749,39 +800,39 @@ test_main( int , char * [] )
    MyShort l2(2);
    MyShort l;
-    BOOST_TEST( l1.value() == 1 );
+    BOOST_CHECK( l1.value() == 1 );
-    BOOST_TEST( l2.value() == 2 );
+    BOOST_CHECK( l2.value() == 2 );
-    BOOST_TEST( l.value() == 0 );
+    BOOST_CHECK( l.value() == 0 );
    cout << "Created MyShort objects.\n";
    PRIVATE_EXPR_TEST( (l = l2), (l.value() == 2) );
-    BOOST_TEST( l2 == l );
+    BOOST_CHECK( static_cast<bool>(l2 == l) );
-    BOOST_TEST( 2 == l );
+    BOOST_CHECK( static_cast<bool>(2 == l) );
-    BOOST_TEST( l2 == 2 );    
+    BOOST_CHECK( static_cast<bool>(l2 == 2) );
-    BOOST_TEST( l == l2 );
+    BOOST_CHECK( static_cast<bool>(l == l2) );
-    BOOST_TEST( l1 != l2 );
+    BOOST_CHECK( static_cast<bool>(l1 != l2) );
-    BOOST_TEST( l1 != 2 );
+    BOOST_CHECK( static_cast<bool>(l1 != 2) );
-    BOOST_TEST( 1 != l2 );
+    BOOST_CHECK( static_cast<bool>(1 != l2) );
-    BOOST_TEST( l1 <  l2 );
+    BOOST_CHECK( static_cast<bool>(l1 <  l2) );
-    BOOST_TEST( 1 <  l2 );
+    BOOST_CHECK( static_cast<bool>(1 <  l2) );
-    BOOST_TEST( l1 <  2 );
+    BOOST_CHECK( static_cast<bool>(l1 <  2) );
-    BOOST_TEST( l1 <= l2 );
+    BOOST_CHECK( static_cast<bool>(l1 <= l2) );
-    BOOST_TEST( 1 <= l2 );
+    BOOST_CHECK( static_cast<bool>(1 <= l2) );
-    BOOST_TEST( l1 <= l );
+    BOOST_CHECK( static_cast<bool>(l1 <= l) );
-    BOOST_TEST( l <= l2 );
+    BOOST_CHECK( static_cast<bool>(l <= l2) );
-    BOOST_TEST( 2 <= l2 );
+    BOOST_CHECK( static_cast<bool>(2 <= l2) );
-    BOOST_TEST( l <= 2 );
+    BOOST_CHECK( static_cast<bool>(l <= 2) );
-    BOOST_TEST( l2 >  l1 );
+    BOOST_CHECK( static_cast<bool>(l2 >  l1) );
-    BOOST_TEST( 2 >  l1 );
+    BOOST_CHECK( static_cast<bool>(2 >  l1) );
-    BOOST_TEST( l2 >  1 );
+    BOOST_CHECK( static_cast<bool>(l2 >  1) );
-    BOOST_TEST( l2 >= l1 );
+    BOOST_CHECK( static_cast<bool>(l2 >= l1) );
-    BOOST_TEST( 2 >= l1 );
+    BOOST_CHECK( static_cast<bool>(2 >= l1) );
-    BOOST_TEST( l2 >= 1 );
+    BOOST_CHECK( static_cast<bool>(l2 >= 1) );
-    BOOST_TEST( l2 >= l );
+    BOOST_CHECK( static_cast<bool>(l2 >= l) );
-    BOOST_TEST( 2 >= l );
+    BOOST_CHECK( static_cast<bool>(2 >= l) );
-    BOOST_TEST( l2 >= 2 );
+    BOOST_CHECK( static_cast<bool>(l2 >= 2) );
    cout << "Performed tests on MyShort objects.\n";
@ -791,46 +842,46 @@ test_main( int , char * [] )
    MyDoubleInt di;
    MyDoubleInt tmp;
-    BOOST_TEST( di1.value() == 1 );
+    BOOST_CHECK( di1.value() == 1 );
-    BOOST_TEST( di2.value() == 2 );
+    BOOST_CHECK( di2.value() == 2 );
-    BOOST_TEST( di2.value() == 2 );
+    BOOST_CHECK( di2.value() == 2 );
-    BOOST_TEST( di.value() == 0 );
+    BOOST_CHECK( di.value() == 0 );
    cout << "Created MyDoubleInt objects.\n";
    PRIVATE_EXPR_TEST( (di = di2), (di.value() == 2) );
-    BOOST_TEST( di2 == di );
+    BOOST_CHECK( static_cast<bool>(di2 == di) );
-    BOOST_TEST( 2 == di );
+    BOOST_CHECK( static_cast<bool>(2 == di) );
-    BOOST_TEST( di == 2 );
+    BOOST_CHECK( static_cast<bool>(di == 2) );
-    BOOST_TEST( di1 < di2 );
+    BOOST_CHECK( static_cast<bool>(di1 < di2) );
-    BOOST_TEST( 1 < di2 );
+    BOOST_CHECK( static_cast<bool>(1 < di2) );
-    BOOST_TEST( di1 <= di2 );
+    BOOST_CHECK( static_cast<bool>(di1 <= di2) );
-    BOOST_TEST( 1 <= di2 );
+    BOOST_CHECK( static_cast<bool>(1 <= di2) );
-    BOOST_TEST( di2 > di1 );
+    BOOST_CHECK( static_cast<bool>(di2 > di1) );
-    BOOST_TEST( di2 > 1 );
+    BOOST_CHECK( static_cast<bool>(di2 > 1) );
-    BOOST_TEST( di2 >= di1 );
+    BOOST_CHECK( static_cast<bool>(di2 >= di1) );
-    BOOST_TEST( di2 >= 1 );
+    BOOST_CHECK( static_cast<bool>(di2 >= 1) );
-    BOOST_TEST( di1 / di2 == half );
+    BOOST_CHECK( static_cast<bool>(di1 / di2 == half) );
-    BOOST_TEST( di1 / 2 == half );
+    BOOST_CHECK( static_cast<bool>(di1 / 2 == half) );
-    BOOST_TEST( 1 / di2 == half );
+    BOOST_CHECK( static_cast<bool>(1 / di2 == half) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=2) == half) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp/=2) == half) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=di2) == half) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp/=di2) == half) );
-    BOOST_TEST( di1 * di2 == di2 );
+    BOOST_CHECK( static_cast<bool>(di1 * di2 == di2) );
-    BOOST_TEST( di1 * 2 == di2 );
+    BOOST_CHECK( static_cast<bool>(di1 * 2 == di2) );
-    BOOST_TEST( 1 * di2 == di2 );
+    BOOST_CHECK( static_cast<bool>(1 * di2 == di2) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=2) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp*=2) == di2) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=di2) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp*=di2) == di2) );
-    BOOST_TEST( di2 - di1 == di1 );
+    BOOST_CHECK( static_cast<bool>(di2 - di1 == di1) );
-    BOOST_TEST( di2 - 1 == di1 );
+    BOOST_CHECK( static_cast<bool>(di2 - 1 == di1) );
-    BOOST_TEST( 2 - di1 == di1 );
+    BOOST_CHECK( static_cast<bool>(2 - di1 == di1) );
-    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=1) == di1) );
+    PRIVATE_EXPR_TEST( (tmp=di2), static_cast<bool>((tmp-=1) == di1) );
-    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=di1) == di1) );
+    PRIVATE_EXPR_TEST( (tmp=di2), static_cast<bool>((tmp-=di1) == di1) );
-    BOOST_TEST( di1 + di1 == di2 );
+    BOOST_CHECK( static_cast<bool>(di1 + di1 == di2) );
-    BOOST_TEST( di1 + 1 == di2 );
+    BOOST_CHECK( static_cast<bool>(di1 + 1 == di2) );
-    BOOST_TEST( 1 + di1 == di2 );
+    BOOST_CHECK( static_cast<bool>(1 + di1 == di2) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=1) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp+=1) == di2) );
-    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=di1) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), static_cast<bool>((tmp+=di1) == di2) );
    cout << "Performed tests on MyDoubleInt objects.\n";
@ -839,50 +890,50 @@ test_main( int , char * [] )
    MyLongInt li;
    MyLongInt tmp2;
-    BOOST_TEST( li1.value() == 1 );
+    BOOST_CHECK( li1.value() == 1 );
-    BOOST_TEST( li2.value() == 2 );
+    BOOST_CHECK( li2.value() == 2 );
-    BOOST_TEST( li.value() == 0 );
+    BOOST_CHECK( li.value() == 0 );
    cout << "Created MyLongInt objects.\n";
    PRIVATE_EXPR_TEST( (li = li2), (li.value() == 2) );
-    BOOST_TEST( li2 == li );
+    BOOST_CHECK( static_cast<bool>(li2 == li) );
-    BOOST_TEST( 2 == li );
+    BOOST_CHECK( static_cast<bool>(2 == li) );
-    BOOST_TEST( li == 2 );
+    BOOST_CHECK( static_cast<bool>(li == 2) );
-    BOOST_TEST( li1 < li2 );
+    BOOST_CHECK( static_cast<bool>(li1 < li2) );
-    BOOST_TEST( 1 < li2 );
+    BOOST_CHECK( static_cast<bool>(1 < li2) );
-    BOOST_TEST( li1 <= li2 );
+    BOOST_CHECK( static_cast<bool>(li1 <= li2) );
-    BOOST_TEST( 1 <= li2 );
+    BOOST_CHECK( static_cast<bool>(1 <= li2) );
-    BOOST_TEST( li2 > li1 );
+    BOOST_CHECK( static_cast<bool>(li2 > li1) );
-    BOOST_TEST( li2 > 1 );
+    BOOST_CHECK( static_cast<bool>(li2 > 1) );
-    BOOST_TEST( li2 >= li1 );
+    BOOST_CHECK( static_cast<bool>(li2 >= li1) );
-    BOOST_TEST( li2 >= 1 );
+    BOOST_CHECK( static_cast<bool>(li2 >= 1) );
-    BOOST_TEST( li1 % li2 == li1 );
+    BOOST_CHECK( static_cast<bool>(li1 % li2 == li1) );
-    BOOST_TEST( li1 % 2 == li1 );
+    BOOST_CHECK( static_cast<bool>(li1 % 2 == li1) );
-    BOOST_TEST( 1 % li2 == li1 );
+    BOOST_CHECK( static_cast<bool>(1 % li2 == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=2) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2%=2) == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=li2) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2%=li2) == li1) );
-    BOOST_TEST( li1 / li2 == 0 );
+    BOOST_CHECK( static_cast<bool>(li1 / li2 == 0) );
-    BOOST_TEST( li1 / 2 == 0 );
+    BOOST_CHECK( static_cast<bool>(li1 / 2 == 0) );
-    BOOST_TEST( 1 / li2 == 0 );
+    BOOST_CHECK( static_cast<bool>(1 / li2 == 0) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=2) == 0) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2/=2) == 0) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=li2) == 0) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2/=li2) == 0) );
-    BOOST_TEST( li1 * li2 == li2 );
+    BOOST_CHECK( static_cast<bool>(li1 * li2 == li2) );
-    BOOST_TEST( li1 * 2 == li2 );
+    BOOST_CHECK( static_cast<bool>(li1 * 2 == li2) );
-    BOOST_TEST( 1 * li2 == li2 );
+    BOOST_CHECK( static_cast<bool>(1 * li2 == li2) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=2) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2*=2) == li2) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=li2) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2*=li2) == li2) );
-    BOOST_TEST( li2 - li1 == li1 );
+    BOOST_CHECK( static_cast<bool>(li2 - li1 == li1) );
-    BOOST_TEST( li2 - 1 == li1 );
+    BOOST_CHECK( static_cast<bool>(li2 - 1 == li1) );
-    BOOST_TEST( 2 - li1 == li1 );
+    BOOST_CHECK( static_cast<bool>(2 - li1 == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=1) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li2), static_cast<bool>((tmp2-=1) == li1) );
-    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=li1) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li2), static_cast<bool>((tmp2-=li1) == li1) );
-    BOOST_TEST( li1 + li1 == li2 );
+    BOOST_CHECK( static_cast<bool>(li1 + li1 == li2) );
-    BOOST_TEST( li1 + 1 == li2 );
+    BOOST_CHECK( static_cast<bool>(li1 + 1 == li2) );
-    BOOST_TEST( 1 + li1 == li2 );
+    BOOST_CHECK( static_cast<bool>(1 + li1 == li2) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=1) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2+=1) == li2) );
-    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=li1) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), static_cast<bool>((tmp2+=li1) == li2) );
    cout << "Performed tests on MyLongInt objects.\n";
--- a/permutation_iterator.htm
+++ b/permutation_iterator.htm
@ -1,177 +0,0 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <html>
 <head>
 <title>Permutation Iterator Adaptor Documentation</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <h1>Permutation Iterator Adaptor</h1>
 <p>Defined in header <a href="../../boost/permutation_iterator.hpp">boost/permutation_iterator.hpp</a></p>
 <p>The permutation iterator adaptor provides an iterator to a permutation of a given range.
 (<a href="http://www.cut-the-knot.com/do_you_know/permutation.html">see definition of permutation</a>).
 The adaptor takes two arguments
 <ul>
 <li>an iterator to the range V on which the <a href="http://www.cut-the-knot.com/do_you_know/permutation.html">permutation</a> will be applied</li>
 <li>the reindexing scheme that defines how the elements of V will be permuted.</li>
 </ul>
 <p>Note that the permutation iterator is not limited to strict permutations of the given range V. 
 The distance between begin and end of the reindexing iterators is allowed to be smaller compared to the 
 size of the range V, in which case the permutation iterator only provides a permutation of a subrange of V. 
 The indexes neither need to be unique. In this same context, it must be noted that the past the end permutation iterator is 
 completely defined by means of the past-the-end iterator to the indices</p> 
 <h2>Synopsis</h2>
 <blockquote>
 <pre>
 namespace boost {
  template &lt;class IndexIterator&gt;
  class permutation_iterator_policies;
  template &lt;class ElementIterator, class IndexIterator&gt;
  class permutation_iterator_generator;
  template &lt;class ElementIterator, class IndexIterator&gt;
  typename permutation_iterator_generator&lt;ElementIterator, IndexIterator&gt;::type
  make_permutation_iterator(ElementIterator&amp; base, IndexIterator&amp; indexing);
 }
 </pre>
 </blockquote>
 <h2>The Permutation Iterator Generator Class Template</h2>
 <p>The <code>permutation_iterator_generator</code> is a helper class whose purpose
 is to construct a permutation iterator <strong>type</strong>. This class has
 two template arguments, the first being the iterator type over the range V, the
 second being the type of the iterator over the indices.
 <blockquote>
 <pre>
 template &lt;class ElementIterator, class IndexIterator&gt;
 class permutation_iterator_generator
 {
 public:
  typedef <a href="iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt; type; // the resulting permutation iterator type 
 }
 </pre>
 </blockquote>
 <h3>Template Parameters</h3>
 <table border>
 <tr>
 <th>Parameter</th>
 <th>Description</th>
 </tr>
 <tr>
 <td><tt>ElementIterator</tt></td>
 <td>The iterator over the elements to be permuted. This type must be a model
 of <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a></td>
 </td>
 <tr>
 <td><tt>IndexIterator</tt></td>
 <td>The iterator over the new indexing scheme. This type must at least be a model
 of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>.
 The <code>IndexIterator::value_type</code> must be convertible to the 
 <code>ElementIterator::difference_type</code>.</td>
 </table>
 <h3>Concept Model</h3>
 The permutation iterator is always a model of the same concept as the IndexIterator.
 <h3>Members</h3>
 The permutation iterator implements the member functions
 and operators required for the 
 <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
 concept. However, the permutation iterator can only meet the complexity guarantees 
 of the same concept as the IndexIterator. Thus for instance, although the permutation
 iterator provides <code>operator+=(distance)</code>, this operation will take linear time
 in case the IndexIterator is a model of ForwardIterator instead of amortized constant time.
 <br>
 <h2><a name="make_generator_iterator">The Permutation Iterator Object Generator</a></h2>
 The <code>make_permutation_iterator()</code> function provides a
 convenient way to create permutation iterator objects. The function
 saves the user the trouble of explicitly writing out the iterator
 types.
 <blockquote>
 <pre>
 template &lt;class ElementIterator, class IndexIterator &gt;
 typename permutation_iterator_generator&lt;ElementIterator, IndexIterator&gt;::type
 make_permutation_iterator(ElementIterator&amp; base, IndexIterator&amp; indices);
 </pre>
 </blockquote>
 <h2>Example</h2>
 <blockquote>
 <pre>
  using namespace boost;
  int i = 0;
  typedef std::vector< int > element_range_type;
  typedef std::list< int > index_type;
  static const int element_range_size = 10;
  static const int index_size = 4;
  element_range_type elements( element_range_size );
  for(element_range_type::iterator el_it = elements.begin() ; el_it != elements.end() ; ++el_it) *el_it = std::distance(elements.begin(), el_it);
  index_type indices( index_size );
  for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it ) *i_it = element_range_size - index_size + std::distance(indices.begin(), i_it);
  std::reverse( indices.begin(), indices.end() );
  typedef permutation_iterator_generator< element_range_type::iterator, index_type::iterator >::type permutation_type;
  permutation_type begin = make_permutation_iterator( elements.begin(), indices.begin() );
  permutation_type it = begin;
  permutation_type end = make_permutation_iterator( elements.begin(), indices.end() );
  std::cout << "The original range is : ";
  std::copy( elements.begin(), elements.end(), std::ostream_iterator< int >( std::cout, " " ) );
  std::cout << "\n";
  std::cout << "The reindexing scheme is : ";
  std::copy( indices.begin(), indices.end(), std::ostream_iterator< int >( std::cout, " " ) );
  std::cout << "\n";
  std::cout << "The permutated range is : ";
  std::copy( begin, end, std::ostream_iterator< int >( std::cout, " " ) );
  std::cout << "\n";
  std::cout << "Elements at even indices in the permutation : ";
  it = begin;
  for(i = 0; i < index_size / 2 ; ++i, it+=2 ) std::cout << *it << " ";
  std::cout << "\n";
  std::cout << "Permutation backwards : ";
  it = begin + (index_size);
  assert( it != begin );
  for( ; it-- != begin ; ) std::cout << *it << " ";
  std::cout << "\n";
  std::cout << "Iterate backward with stride 2 : ";
  it = begin + (index_size - 1);
  for(i = 0 ; i < index_size / 2 ; ++i, it-=2 ) std::cout << *it << " ";
  std::cout << "\n";
 </pre>
 </blockquote>
 <br><br><br><hr>
 Thanks: The permutation iterator is only a small addition to the superb iterator adaptors
 library of David Abrahams and Jeremy Siek.
 <br><br>
 Copyright 2001 Toon Knapen.
 </body>
 </html>
--- a/Show More
+++ b/Show More