v2, v3, integration branch

[SVN r62649]
Made memset call in value_init conditional, see #3869 . Updated the section "compiler issues" of its documentation.
2010-06-09 11:34:33 +00:00 · 2010-05-30 09:19:09 +00:00 · 2010-05-22 22:05:54 +00:00 · 2010-05-16 11:08:00 +00:00 · 2010-05-13 14:36:06 +00:00 · 2010-05-09 20:51:24 +00:00
130 changed files with 16952 additions and 4227 deletions
--- a/Assignable.html
+++ b/Assignable.html
@ -0,0 +1,109 @@
 <!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>Assignable</title>
 </head>
 <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 "#FF0000">
  <img src="../../boost.png" alt="C++ Boost" width="277" height=
  "86"><br clear="none">
  <h1>Assignable</h1>
  <h3>Description</h3>
  <p>A type is Assignable if it is possible to assign one object of the type
  to another object of that type.</p>
  <h3>Notation</h3>
  <table summary="">
    <tr>
      <td valign="top"><tt>T</tt></td>
      <td valign="top">is type that is a model of Assignable</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>T</tt> or possibly <tt>const
      T</tt></td>
    </tr>
  </table>
  <h3>Definitions</h3>
  <h3>Valid expressions</h3>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Return type</th>
      <th>Semantics</th>
    </tr>
    <tr>
      <td valign="top">Assignment</td>
      <td valign="top"><tt>t = u</tt></td>
      <td valign="top"><tt>T&amp;</tt></td>
      <td valign="top"><tt>t</tt> is equivalent to <tt>u</tt></td>
    </tr>
  </table>
  <h3>Models</h3>
  <ul>
    <li><tt>int</tt></li>
    <li><tt>std::pair</tt></li>
  </ul>
  <h3>See also</h3>
  <p><a href=
  "http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>
  and <a href="./CopyConstructible.html">CopyConstructible</a><br></p>
  <hr>
  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
  height="31" width="88"></a></p>
  <p>Revised 
  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
  <table summary="">
    <tr valign="top">
      <td nowrap><i>Copyright &copy; 2000</i></td>
      <td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
      Notre Dame (<a href=
      "mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
    </tr>
  </table>
  <p><i>Distributed under the Boost Software License, Version 1.0. (See
  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
  copy at <a href=
  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
 </body>
 </html>
--- a/Collection.html
+++ b/Collection.html
@ -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
@ -0,0 +1,185 @@
 <!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>Copy Constructible</title>
 </head>
 <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 "#FF0000">
  <img src="../../boost.png" alt="C++ Boost" width="277" height=
  "86"><br clear="none">
  <h1>Copy Constructible</h1>
  <h3>Description</h3>
  <p>A type is Copy Constructible if it is possible to copy objects of that
  type.</p>
  <h3>Notation</h3>
  <table summary="">
    <tr>
      <td valign="top"><tt>T</tt></td>
      <td valign="top">is type that is a model of Copy Constructible</td>
    </tr>
    <tr>
      <td valign="top"><tt>t</tt></td>
      <td valign="top">is an object of type <tt>T</tt></td>
    </tr>
    <tr>
      <td valign="top"><tt>u</tt></td>
      <td valign="top">is an object of type <tt>const T</tt></td>
    </tr>
  </table>
  <h3>Definitions</h3>
  <h3>Valid expressions</h3>
  <table border summary="">
    <tr>
      <th>Name</th>
      <th>Expression</th>
      <th>Return type</th>
      <th>Semantics</th>
    </tr>
    <tr>
      <td valign="top">Copy constructor</td>
      <td valign="top"><tt>T(t)</tt></td>
      <td valign="top"><tt>T</tt></td>
      <td valign="top"><tt>t</tt> is equivalent to <tt>T(t)</tt></td>
    </tr>
    <tr>
      <td valign="top">Copy constructor</td>
      <td valign="top">
        <pre>
 T(u)
 </pre>
      </td>
      <td valign="top"><tt>T</tt></td>
      <td valign="top"><tt>u</tt> is equivalent to <tt>T(u)</tt></td>
    </tr>
    <tr>
      <td valign="top">Destructor</td>
      <td valign="top">
        <pre>
 t.~T()
 </pre>
      </td>
      <td valign="top"><tt>T</tt></td>
      <td valign="top">&nbsp;</td>
    </tr>
    <tr>
      <td valign="top">Address Operator</td>
      <td valign="top">
        <pre>
 &amp;t
 </pre>
      </td>
      <td valign="top"><tt>T*</tt></td>
      <td valign="top">denotes the address of <tt>t</tt></td>
    </tr>
    <tr>
      <td valign="top">Address Operator</td>
      <td valign="top">
        <pre>
 &amp;u
 </pre>
      </td>
      <td valign="top"><tt>T*</tt></td>
      <td valign="top">denotes the address of <tt>u</tt></td>
    </tr>
  </table>
  <h3>Models</h3>
  <ul>
    <li><tt>int</tt></li>
    <li><tt>std::pair</tt></li>
  </ul>
  <h3>Concept Checking Class</h3>
  <pre>
  template &lt;class T&gt;
  struct CopyConstructibleConcept
  {
    void constraints() {
      T a(b);            // require copy constructor
      T* ptr = &amp;a;       // require address of operator
      const_constraints(a);
      ignore_unused_variable_warning(ptr);
    }
    void const_constraints(const T&amp; a) {
      T c(a);            // require const copy constructor
      const T* ptr = &amp;a; // require const address of operator
      ignore_unused_variable_warning(c);
      ignore_unused_variable_warning(ptr);
    }
    T b;
  };
 </pre>
  <h3>See also</h3>
  <p><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
  Constructible</a> and <a href="./Assignable.html">Assignable</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/LessThanComparable.html
+++ b/LessThanComparable.html
@ -0,0 +1,210 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <!--
  == 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>
  <meta http-equiv="Content-Language" content="en-us">
  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
  <title>LessThanComparable</title>
 </head>
 <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 "#FF0000">
  <img src="../../boost.png" alt="C++ Boost" width="277" height=
  "86"><br clear="none">
  <h1>LessThanComparable</h1>
  <h3>Description</h3>
  <p>A type is LessThanComparable if it is ordered: it must be possible to
  compare two objects of that type using <tt>operator&lt;</tt>, and
  <tt>operator&lt;</tt> must be a strict weak ordering relation.</p>
  <h3>Refinement of</h3>
  <h3>Associated types</h3>
  <h3>Notation</h3>
  <table summary="">
    <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>
  <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
@ -0,0 +1,95 @@
 <!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>MultiPassInputIterator</title>
 </head>
 <body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
 "#FF0000">
  <img src="../../boost.png" alt="C++ Boost" width="277" height=
  "86"><br clear="none">
  <h2><a name="concept:MultiPassInputIterator" id=
  "concept:MultiPassInputIterator"></a> Multi-Pass Input Iterator</h2>
  <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>
  <h3>Design Notes</h3>
  <p>comments by Valentin Bonnard:</p>
  <p>I think that introducing Multi-Pass Input Iterator isn't the right
  solution. Do you also want to define Multi-Pass Bidirectionnal Iterator and
  Multi-Pass Random Access Iterator ? I don't, definitly. It only confuses
  the issue. The problem lies into the existing hierarchy of iterators, which
  mixes movabillity, modifiabillity and lvalue-ness, and these are clearly
  independant.</p>
  <p>The terms Forward, Bidirectionnal and Random Access are about
  movabillity and shouldn't be used to mean anything else. In a completly
  orthogonal way, iterators can be immutable, mutable, or neither. Lvalueness
  of iterators is also orthogonal with immutabillity. With these clean
  concepts, your Multi-Pass Input Iterator is just called a Forward
  Iterator.</p>
  <p>Other translations are:<br>
  std::Forward Iterator -&gt; ForwardIterator &amp; Lvalue Iterator<br>
  std::Bidirectionnal Iterator -&gt; Bidirectionnal Iterator &amp; Lvalue
  Iterator<br>
  std::Random Access Iterator -&gt; Random Access Iterator &amp; Lvalue
  Iterator<br></p>
  <p>Note that in practice the only operation not allowed on my Forward
  Iterator which is allowed on std::Forward Iterator is <tt>&amp;*it</tt>. I
  think that <tt>&amp;*</tt> is rarely needed in generic code.</p>
  <p>reply by Jeremy Siek:</p>
  <p>The above analysis by Valentin is right on. Of course, there is the
  problem with backward compatibility. The current STL implementations are
  based on the old definition of Forward Iterator. The right course of action
  is to get Forward Iterator, etc. changed in the C++ standard. Once that is
  done we can drop Multi-Pass Input Iterator.<br></p>
  <hr>
  <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/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
@ -0,0 +1,94 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
 //                    Douglas Gregor (gregod@cs.rpi.edu)
 //
 // 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 );
 }
 struct addressable
 {
    addressable( int = 0 )
    {
    }
 };
 struct useless_type {};
 class nonaddressable {
 public:
    nonaddressable( int = 0 )
    {
    }
    void dummy(); // Silence GCC warning: all member of class are private
 private:
    useless_type operator&() const;
 };
 int main()
 {
    scalar_test<char>();
    scalar_test<int>();
    scalar_test<addressable>();
    scalar_test<nonaddressable>();
    array_test<char>();
    array_test<int>();
    array_test<addressable>();
    array_test<nonaddressable>();
    return boost::report_errors();
 }
--- a/addressof_test2.cpp
+++ b/addressof_test2.cpp
@ -0,0 +1,95 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
 //                    Douglas Gregor (gregod@cs.rpi.edu)
 //
 // Copyright 2009 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // For more information, see http://www.boost.org
 #include <boost/utility/addressof.hpp>
 #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
 #pragma warning(push, 3)
 #endif
 #include <iostream>
 #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
 #pragma warning(pop)
 #endif
 #include <boost/detail/lightweight_test.hpp>
 template<class T> void scalar_test( T * = 0 )
 {
    T* px = new T();
    T& x = *px;
    BOOST_TEST( boost::addressof(x) == px );
    const T& cx = *px;
    const T* pcx = boost::addressof(cx);
    BOOST_TEST( pcx == px );
    volatile T& vx = *px;
    volatile T* pvx = boost::addressof(vx);
    BOOST_TEST( pvx == px );
    const volatile T& cvx = *px;
    const volatile T* pcvx = boost::addressof(cvx);
    BOOST_TEST( pcvx == px );
    delete px;
 }
 template<class T> void array_test( T * = 0 )
 {
    T nrg[3] = {1,2,3};
    T (*pnrg)[3] = &nrg;
    BOOST_TEST( boost::addressof(nrg) == pnrg );
    T const cnrg[3] = {1,2,3};
    T const (*pcnrg)[3] = &cnrg;
    BOOST_TEST( boost::addressof(cnrg) == pcnrg );
 }
 class convertible {
 public:
    convertible( int = 0 )
    {
    }
    template<class U> operator U () const
    {
        return U();
    }
 };
 class convertible2 {
 public:
    convertible2( int = 0 )
    {
    }
    operator convertible2* () const
    {
        return 0;
    }
 };
 int main()
 {
    scalar_test<convertible>();
    scalar_test<convertible2>();
    array_test<convertible>();
    array_test<convertible2>();
    return boost::report_errors();
 }
--- a/algo_opt_examples.cpp
+++ b/algo_opt_examples.cpp
@ -1,423 +0,0 @@
 /*
 *
 * Copyright (c) 1999
 * Dr John Maddock
 *
 * 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 appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Dr John Maddock makes no representations
 * about the suitability of this software for any purpose.
 * It is provided "as is" without express or implied warranty.
 *
 * This file provides some example of type_traits usage -
 * by "optimising" various algorithms:
 *
 * opt::copy - optimised for trivial copy (cf std::copy)
 * opt::fill - optimised for trivial copy/small types (cf std::fill)
 * opt::destroy_array - an example of optimisation based upon omitted destructor calls
 * opt::iter_swap - uses type_traits to determine whether the iterator is a proxy
 *                  in which case it uses a "safe" approach, otherwise calls swap
 *                  on the assumption that swap may be specialised for the pointed-to type.
 *
 */
 /* Release notes:
   23rd July 2000:
      Added explicit failure for broken compilers that don't support these examples.
      Fixed broken gcc support (broken using directive).
      Reordered tests slightly.
 */
 #include <iostream>
 #include <typeinfo>
 #include <algorithm>
 #include <iterator>
 #include <vector>
 #include <memory>
 #include <boost/timer.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/call_traits.hpp>
 using std::cout;
 using std::endl;
 using std::cin;
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #error "Sorry, without template partial specialisation support there isn't anything to test here..."
 #endif
 namespace opt{
 //
 // algorithm destroy_array:
 // The reverse of std::unitialized_copy, takes a block of
 // unitialized memory and calls destructors on all objects therein.
 //
 namespace detail{
 template <bool>
 struct array_destroyer
 {
   template <class T>
   static void destroy_array(T* i, T* j){ do_destroy_array(i, j); }
 };
 template <>
 struct array_destroyer<true>
 {
   template <class T>
   static void destroy_array(T*, T*){}
 };
 template <class T>
 void do_destroy_array(T* first, T* last)
 {
   while(first != last)
   {
      first->~T();
      ++first;
   }
 }
 }; // namespace detail
 template <class T>
 inline void destroy_array(T* p1, T* p2)
 {
   detail::array_destroyer<boost::has_trivial_destructor<T>::value>::destroy_array(p1, p2);
 }
 //
 // unoptimised versions of destroy_array:
 //
 template <class T>
 void destroy_array1(T* first, T* last)
 {
   while(first != last)
   {
      first->~T();
      ++first;
   }
 }
 template <class T>
 void destroy_array2(T* first, T* last)
 {
   for(; first != last; ++first) first->~T();
 }
 //
 // opt::copy
 // same semantics as std::copy
 // calls memcpy where appropiate.
 //
 namespace detail{
 template <bool b>
 struct copier
 {
   template<typename I1, typename I2>
   static I2 do_copy(I1 first, I1 last, I2 out);
 };
 template <bool b>
 template<typename I1, typename I2>
 I2 copier<b>::do_copy(I1 first, I1 last, I2 out)
 {
   while(first != last)
   {
      *out = *first;
      ++out;
      ++first;
   }
   return out;
 }
 template <>
 struct copier<true>
 {
   template<typename I1, typename I2>
   static I2* do_copy(I1* first, I1* last, I2* out)
   {
      memcpy(out, first, (last-first)*sizeof(I2));
      return out+(last-first);
   }
 };
 }
 template<typename I1, typename I2>
 inline I2 copy(I1 first, I1 last, I2 out)
 {
   typedef typename boost::remove_cv<typename std::iterator_traits<I1>::value_type>::type v1_t;
   typedef typename boost::remove_cv<typename std::iterator_traits<I2>::value_type>::type v2_t;
   enum{ can_opt = boost::is_same<v1_t, v2_t>::value
                   && boost::is_pointer<I1>::value
                   && boost::is_pointer<I2>::value
                   && boost::has_trivial_assign<v1_t>::value };
   return detail::copier<can_opt>::do_copy(first, last, out);
 }
 //
 // fill
 // same as std::fill, uses memset where appropriate, along with call_traits
 // to "optimise" parameter passing.
 //
 namespace detail{
 template <bool opt>
 struct filler
 {
   template <typename I, typename T>
   static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val);
 };
 template <bool b>
 template <typename I, typename T>
 void filler<b>::do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
 {
   while(first != last)
   {
      *first = val;
      ++first;
   }
 }
 template <>
 struct filler<true>
 {
   template <typename I, typename T>
   static void do_fill(I first, I last, T val)
   {
      memset(first, val, last-first);
   }
 };
 }
 template <class I, class T>
 inline void fill(I first, I last, const T& val)
 {
   enum{ can_opt = boost::is_pointer<I>::value
                   && boost::is_arithmetic<T>::value
                   && (sizeof(T) == 1) };
   typedef detail::filler<can_opt> filler_t;
   filler_t::template do_fill<I,T>(first, last, val);
 }
 //
 // iter_swap:
 // tests whether iterator is a proxying iterator or not, and
 // uses optimal form accordingly:
 //
 namespace detail{
 template <bool b>
 struct swapper
 {
   template <typename I>
   static void do_swap(I one, I two)
   {
      typedef typename std::iterator_traits<I>::value_type v_t;
      v_t v = *one;
      *one = *two;
      *two = v;
   }
 };
 #ifdef __GNUC__
 using std::swap;
 #endif
 template <>
 struct swapper<true>
 {
   template <typename I>
   static void do_swap(I one, I two)
   {
      using std::swap;
      swap(*one, *two);
   }
 };
 }
 template <typename I1, typename I2>
 inline void iter_swap(I1 one, I2 two)
 {
   typedef typename std::iterator_traits<I1>::reference r1_t;
   typedef typename std::iterator_traits<I2>::reference r2_t;
   enum{ can_opt = boost::is_reference<r1_t>::value && boost::is_reference<r2_t>::value && boost::is_same<r1_t, r2_t>::value };
   detail::swapper<can_opt>::do_swap(one, two);
 }
 };   // namespace opt
 //
 // define some global data:
 //
 const int array_size = 1000;
 int i_array[array_size] = {0,};
 const int ci_array[array_size] = {0,};
 char c_array[array_size] = {0,};
 const char cc_array[array_size] = { 0,};
 const int iter_count = 1000000;
 int main()
 {
   //
   // test destroy_array,
   // compare destruction time of an array of ints
   // with unoptimised form.
   //
   cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
   cout << "testing destroy_array...\n"
    "[Some compilers may be able to optimise the \"unoptimised\"\n versions as well as type_traits does.]" << endl;
   /*cache load*/ opt::destroy_array(i_array, i_array + array_size);
   boost::timer t;
   double result;
   int i;
   for(i = 0; i < iter_count; ++i)
   {
      opt::destroy_array(i_array, i_array + array_size);
   }
   result = t.elapsed();
   cout << "destroy_array<int>: " << result << endl;
   /*cache load*/ opt::destroy_array1(i_array, i_array + array_size);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      opt::destroy_array1(i_array, i_array + array_size);
   }
   result = t.elapsed();
   cout << "destroy_array<int>(unoptimised#1): " << result << endl;
   /*cache load*/ opt::destroy_array2(i_array, i_array + array_size);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      opt::destroy_array2(i_array, i_array + array_size);
   }
   result = t.elapsed();
   cout << "destroy_array<int>(unoptimised#2): " << result << endl << endl;
   cout << "testing fill(char)...\n"
   "[Some standard library versions may already perform this optimisation.]" << endl;
   /*cache load*/ opt::fill<char*, char>(c_array, c_array + array_size, (char)3);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      opt::fill<char*, char>(c_array, c_array + array_size, (char)3);
   }
   result = t.elapsed();
   cout << "opt::fill<char*, char>: " << result << endl;
   /*cache load*/ std::fill(c_array, c_array + array_size, (char)3);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      std::fill(c_array, c_array + array_size, (char)3);
   }
   result = t.elapsed();
   cout << "std::fill<char*, char>: " << result << endl << endl;
   cout << "testing fill(int)...\n"
   "[Tests the effect of call_traits pass-by-value optimisation -\nthe value of this optimisation may depend upon hardware characteristics.]" << endl;
   /*cache load*/ opt::fill<int*, int>(i_array, i_array + array_size, 3);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      opt::fill<int*, int>(i_array, i_array + array_size, 3);
   }
   result = t.elapsed();
   cout << "opt::fill<int*, int>: " << result << endl;
   /*cache load*/ std::fill(i_array, i_array + array_size, 3);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      std::fill(i_array, i_array + array_size, 3);
   }
   result = t.elapsed();
   cout << "std::fill<int*, int>: " << result << endl << endl;
   cout << "testing copy...\n"
   "[Some standard library versions may already perform this optimisation.]" << endl;
   /*cache load*/ opt::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      opt::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
   }
   result = t.elapsed();
   cout << "opt::copy<const int*, int*>: " << result << endl;
   /*cache load*/ std::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      std::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
   }
   result = t.elapsed();
   cout << "std::copy<const int*, int*>: " << result << endl;
   /*cache load*/ opt::detail::copier<false>::template do_copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      opt::detail::copier<false>::template do_copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
   }
   result = t.elapsed();
   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
   /*cache load*/ opt::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      opt::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
   }
   result = t.elapsed();
   cout << "opt::copy<const char*, char*>: " << result << endl;
   /*cache load*/ std::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      std::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
   }
   result = t.elapsed();
   cout << "std::copy<const char*, char*>: " << result << endl;
   /*cache load*/ opt::detail::copier<false>::template do_copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
   t.restart();
   for(i = 0; i < iter_count; ++i)
   {
      opt::detail::copier<false>::template do_copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
   }
   result = t.elapsed();
   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
   //
   // testing iter_swap
   // really just a check that it does in fact compile...
   std::vector<int> v1;
   v1.push_back(0);
   v1.push_back(1);
   std::vector<bool> v2;
   v2.push_back(0);
   v2.push_back(1);
   opt::iter_swap(v1.begin(), v1.begin()+1);
   opt::iter_swap(v2.begin(), v2.begin()+1);
   cout << "Press any key to exit...";
   cin.get();
 }
--- a/assert.html
+++ b/assert.html
@ -0,0 +1,61 @@
 <!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>
 			The header <STRONG>&lt;boost/assert.hpp&gt;</STRONG> defines the macro <b>BOOST_ASSERT</b>, 
 			which is similar to the standard <STRONG>assert</STRONG> macro defined in <STRONG>&lt;cassert&gt;</STRONG>. 
 			The macro is intended to be used in Boost libraries.
 		</p>
 		<P>By default, <tt>BOOST_ASSERT(expr)</tt> is equivalent to <tt>assert(expr)</tt>.</P>
 		<P>When the macro <STRONG>BOOST_DISABLE_ASSERTS</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> is defined as <tt>((void)0)</tt>. This 
 			allows users to selectively disable <STRONG>BOOST_ASSERT</STRONG> without 
 			affecting the definition of the standard <STRONG>assert</STRONG>.</P>
 		<P>When the macro <STRONG>BOOST_ENABLE_ASSERT_HANDLER</STRONG> is defined when <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			is included, <tt>BOOST_ASSERT(expr)</tt> evaluates <b>expr</b> and, if the 
 			result is false, evaluates the expression</P>
 		<P><tt>::boost::assertion_failed(#expr, <a href="current_function.html">BOOST_CURRENT_FUNCTION</a>, 
 				__FILE__, __LINE__)</tt></P>
 		<P><STRONG>assertion_failed</STRONG> is declared in <STRONG>&lt;boost/assert.hpp&gt;</STRONG>
 			as</P>
 		<pre>
 namespace boost
 {
 void assertion_failed(char const * expr, char const * function, char const * file, long line);
 }
 </pre>
 		<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>
 		<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. 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
@ -0,0 +1,109 @@
 //
 //  assert_test.cpp - a test for boost/assert.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/assert.hpp>
 void test_default()
 {
    int x = 1;
    BOOST_ASSERT(1);
    BOOST_ASSERT(x);
    BOOST_ASSERT(x == 1);
    BOOST_ASSERT(&x);
 }
 #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(0);
    BOOST_ASSERT(!x);
    BOOST_ASSERT(x == 0);
    void * p = 0;
    BOOST_ASSERT(p);
    // 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>
 int handler_invoked = 0;
 void boost::assertion_failed(char const * expr, char const * function, char const * file, long line)
 {
 #if !defined(BOOST_NO_STDC_NAMESPACE)
    using std::printf;
 #endif
    printf("Expression: %s\nFunction: %s\nFile: %s\nLine: %ld\n\n", expr, function, file, line);
    ++handler_invoked;
 }
 struct X
 {
    static void f()
    {
        BOOST_ASSERT(0);
    }
 };
 void test_handler()
 {
    int x = 1;
    BOOST_ASSERT(1);
    BOOST_ASSERT(x);
    BOOST_ASSERT(x == 1);
    BOOST_ASSERT(&x);
    BOOST_ASSERT(0);
    BOOST_ASSERT(!x);
    BOOST_ASSERT(x == 0);
    void * p = 0;
    BOOST_ASSERT(p);
    X::f();
    BOOST_ASSERT(handler_invoked == 5);
    BOOST_TEST(handler_invoked == 5);
 }
 #undef BOOST_ENABLE_ASSERT_HANDLER
 int main()
 {
    test_default();
    test_disabled();
    test_handler();
    return boost::report_errors();
 }
--- a/base_from_member.html
+++ b/base_from_member.html
@ -0,0 +1,371 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <html>
 <head>
 <title>Boost: Base-from-Member Idiom Documentation</title>
 </head>
 <body bgcolor="white" link="blue" text="black" vlink="purple" alink="red"> 
 <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>.</p>
 <p>There is test/example code in <cite><a
 href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.</p>
 <h2><a name="contents">Contents</a></h2>
 <ul>
 	<li><a href="#contents">Contents</a></li>
 	<li><a href="#rationale">Rationale</a></li>
 	<li><a href="#synopsis">Synopsis</a></li>
 	<li><a href="#usage">Usage</a></li>
 	<li><a href="#example">Example</a></li>
 	<li><a href="#credits">Credits</a>
 		<ul>
 			<li><a href="#contributors">Contributors</a></li>
 		</ul></li>
 </ul>
 <h2><a name="rationale">Rationale</a></h2>
 <p>When developing a class, sometimes a base class needs to be
 initialized with a member of the current class.  As a na&iuml;ve
 example:</p>
 <blockquote><pre>
 #include &lt;streambuf&gt;  <i>// for std::streambuf</i>
 #include &lt;ostream&gt;    <i>// for std::ostream</i>
 class fdoutbuf
    : public std::streambuf
 {
 public:
    explicit fdoutbuf( int fd );
    //...
 };
 class fdostream
    : public std::ostream
 {
 protected:
    fdoutbuf buf;
 public:
    explicit fdostream( int fd )
        : buf( fd ), std::ostream( &amp;buf )
        {}
    //...
 };
 </pre></blockquote>
 <p>This is undefined because C++'s initialization order mandates that
 the base class is initialized before the member it uses.  <a
 href="http://www.moocat.org">R. Samuel Klatchko</a> developed a way
 around this by using the initialization order in his favor.  Base
 classes are intialized in order of declaration, so moving the desired
 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>
 <blockquote><pre>
 #include &lt;streambuf&gt;  <i>// for std::streambuf</i>
 #include &lt;ostream&gt;    <i>// for std::ostream</i>
 class fdoutbuf
    : public std::streambuf
 {
 public:
    explicit fdoutbuf( int fd );
    //...
 };
 struct fdostream_pbase
 {
    fdoutbuf sbuffer;
    explicit fdostream_pbase( int fd )
        : sbuffer( fd )
        {}
 };
 class fdostream
    : private fdostream_pbase
    , public std::ostream
 {
    typedef fdostream_pbase  pbase_type;
    typedef std::ostream     base_type;
 public:
    explicit fdostream( int fd )
        : pbase_type( fd ), base_type( &amp;sbuffer )
        {}
    //...
 };
 </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>Manually coding a base class may be better if the construction
 and/or copying needs are too complex for the supplied template class,
 or if the compiler is not advanced enough to use it.</p>
 <p>Since base classes are unnamed, a class cannot have multiple (direct)
 base classes of the same type.  The supplied template class has an
 extra template parameter, an integer, that exists solely to provide type
 differentiation.  This parameter has a default value so a single use of a
 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;
    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, typename T4,
     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>
 <p>The class template has a first template parameter
 <var>MemberType</var> representing the type of the based-member.
 It has a last template parameter <var>UniqueID</var>, that is an
 <code>int</code>, to differentiate between multiple base classes that use
 the same based-member type.  The last template parameter has a default
 value of zero if it is omitted.  The class template has a protected
 data member called <var>member</var> that the derived class can use
 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 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
 to be encapsulated in a base class that is inheirited before
 <code>std::ostream</code>.</p>
 <blockquote><pre>
 #include &lt;boost/utility/base_from_member.hpp&gt;
 #include &lt;streambuf&gt;  <i>// for std::streambuf</i>
 #include &lt;ostream&gt;    <i>// for std::ostream</i>
 class fdoutbuf
    : public std::streambuf
 {
 public:
    explicit fdoutbuf( int fd );
    //...
 };
 class fdostream
    : private boost::base_from_member&lt;fdoutbuf&gt;
    , public std::ostream
 {
    // Helper typedef's
    typedef boost::base_from_member&lt;fdoutbuf&gt;  pbase_type;
    typedef std::ostream                        base_type;
 public:
    explicit fdostream( int fd )
        : pbase_type( fd ), base_type( &amp;member )
        {}
    //...
 };
 </pre></blockquote>
 <p>The base-from-member idiom is an implementation detail, so it
 should not be visible to the clients (or any derived classes) of
 <code>fdostream</code>.  Due to the initialization order, the
 <code>fdoutbuf</code> sub-object will get initialized before the
 <code>std::ostream</code> sub-object does, making the former
 sub-object safe to use in the latter sub-object's construction.  Since the
 <code>fdoutbuf</code> sub-object of the final type is the only sub-object
 with the name &quot;member,&quot; that name can be used
 unqualified within the final class.</p>
 <h2><a name="example">Example</a></h2>
 <p>The base-from-member class templates should commonly involve
 only one base-from-member sub-object, usually for attaching a
 stream-buffer to an I/O stream.  The next example demonstrates how
 to use multiple base-from-member sub-objects and the resulting
 qualification issues.</p>
 <blockquote><pre>
 #include &lt;boost/utility/base_from_member.hpp&gt;
 #include &lt;cstddef&gt;  <i>// for NULL</i>
 struct an_int
 {
    int  y;
    an_int( float yf );
 };
 class switcher
 {
 public:
    switcher();
    switcher( double, int * );
    //...
 };
 class flow_regulator
 {
 public:
    flow_regulator( switcher &amp;, switcher &amp; );
    //...
 };
 template &lt; unsigned Size &gt;
 class fan
 {
 public:
    explicit fan( switcher );
    //...
 };
 class system
    : private boost::base_from_member&lt;an_int&gt;
    , private boost::base_from_member&lt;switcher&gt;
    , private boost::base_from_member&lt;switcher, 1&gt;
    , private boost::base_from_member&lt;switcher, 2&gt;
    , protected flow_regulator
    , public fan&lt;6&gt;
 {
    // Helper typedef's
    typedef boost::base_from_member&lt;an_int&gt;       pbase0_type;
    typedef boost::base_from_member&lt;switcher&gt;     pbase1_type;
    typedef boost::base_from_member&lt;switcher, 1&gt;  pbase2_type;
    typedef boost::base_from_member&lt;switcher, 2&gt;  pbase3_type;
    typedef flow_regulator  base1_type;
    typedef fan&lt;6&gt;          base2_type;
 public:
    system( double x );
    //...
 };
 system::system( double x )
    : pbase0_type( 0.2 )
    , pbase1_type()
    , pbase2_type( -16, &amp;this-&gt;pbase0_type::member )
    , pbase3_type( x, static_cast&lt;int *&gt;(NULL) )
    , base1_type( pbase3_type::member, pbase1_type::member )
    , base2_type( pbase2_type::member )
 {
    //...
 }
 </pre></blockquote>
 <p>The final class has multiple sub-objects with the name
 &quot;member,&quot; so any use of that name needs qualification by
 a name of the appropriate base type.  (Using <code>typedef</code>s
 ease mentioning the base types.)  However, the fix introduces a new
 problem when a pointer is needed.  Using the address operator with
 a sub-object qualified with its class's name results in a pointer-to-member
 (here, having a type of <code>an_int boost::base_from_member&lt;an_int,
 0&gt; :: *</code>) instead of a pointer to the member (having a type of
 <code>an_int *</code>).  The new problem is fixed by qualifying the
 sub-object with &quot;<code>this-&gt;</code>,&quot; and is needed just
 for pointers, and not for references or values.</p>
 <p>There are some argument conversions in the initialization.  The
 constructor argument for <code>pbase0_type</code> is converted from
 <code>double</code> to <code>float</code>.  The first constructor
 argument for <code>pbase2_type</code> is converted from <code>int</code>
 to <code>double</code>.  The second constructor argument for
 <code>pbase3_type</code> is a special case of necessary conversion; all
 forms of the null-pointer literal in C++ also look like compile-time
 integral expressions, so C++ always interprets such code as an integer
 when it has overloads that can take either an integer or a pointer.  The
 last conversion is necessary for the compiler to call a constructor form
 with the exact pointer type used in <code>switcher</code>'s constructor.</p>
 <h2><a name="credits">Credits</a></h2>
 <h3><a name="contributors">Contributors</a></h3>
 <dl>
 	<dt><a href="http://www.boost.org/people/ed_brey.htm">Ed Brey</a>
 	<dd>Suggested some interface changes.
 	<dt><a href="http://www.moocat.org">R. Samuel Klatchko</a> (<a
 	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="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>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: 28 August 2004</p>
 <p>Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and distribution
 are subject to the Boost Software License, Version 1.0.  (See accompanying
 file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
 href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
 </body>
 </html>
--- a/base_from_member_test.cpp
+++ b/base_from_member_test.cpp
@ -0,0 +1,595 @@
 //  Boost test program for base-from-member class templates  -----------------//
 //  Copyright 2001, 2003 Daryle Walker.  Use, modification, and distribution are
 //  subject to the Boost Software License, Version 1.0.  (See accompanying file
 //  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
 //  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)
 #include <boost/test/minimal.hpp>  // for BOOST_CHECK, main
 #include <boost/config.hpp>       // for BOOST_NO_MEMBER_TEMPLATES
 #include <boost/cstdlib.hpp>      // for boost::exit_success
 #include <boost/noncopyable.hpp>  // for boost::noncopyable
 #include <boost/utility/base_from_member.hpp>  // for boost::base_from_member
 #include <functional>  // for std::binary_function, std::less
 #include <iostream>    // for std::cout (std::ostream, std::endl indirectly)
 #include <set>         // for std::set
 #include <typeinfo>    // for std::type_info
 #include <utility>     // for std::pair, std::make_pair
 #include <vector>      // for std::vector
 // Control if extra information is printed
 #ifndef CONTROL_EXTRA_PRINTING
 #define CONTROL_EXTRA_PRINTING  1
 #endif
 // A (sub)object can be identified by its memory location and its type.
 // Both are needed since an object can start at the same place as its
 // first base class subobject and/or contained subobject.
 typedef std::pair< void *, std::type_info const * >  object_id;
 // Object IDs need to be printed
 std::ostream &  operator <<( std::ostream &os, object_id const &oi );
 // A way to generate an object ID
 template < typename T >
  object_id  identify( T &obj );
 // A custom comparison type is needed
 struct object_id_compare
    : std::binary_function<object_id, object_id, bool>
 {
    bool  operator ()( object_id const &a, object_id const &b ) const;
 };  // object_id_compare
 // A singleton of this type coordinates the acknowledgements
 // of objects being created and used.
 class object_registrar
    : private boost::noncopyable
 {
 public:
    #ifndef BOOST_NO_MEMBER_TEMPLATES
    template < typename T >
        void  register_object( T &obj )
            { this->register_object_imp( identify(obj) ); }
    template < typename T, typename U >
        void  register_use( T &owner, U &owned )
            { this->register_use_imp( identify(owner), identify(owned) ); }
    template < typename T, typename U >
        void  unregister_use( T &owner, U &owned )
            { this->unregister_use_imp( identify(owner), identify(owned) ); }
    template < typename T >
        void  unregister_object( T &obj )
            { this->unregister_object_imp( identify(obj) ); }
    #endif
    void  register_object_imp( object_id obj );
    void  register_use_imp( object_id owner, object_id owned );
    void  unregister_use_imp( object_id owner, object_id owned );
    void  unregister_object_imp( object_id obj );
    typedef std::set<object_id, object_id_compare>  set_type;
    typedef std::vector<object_id>  error_record_type;
    typedef std::vector< std::pair<object_id, object_id> >  error_pair_type;
    set_type  db_;
    error_pair_type    defrauders_in_, defrauders_out_;
    error_record_type  overeager_, overkilled_;
 };  // object_registrar
 // A sample type to be used by containing types
 class base_or_member
 {
 public:
    explicit  base_or_member( int x = 1, double y = -0.25 );
             ~base_or_member();
 };  // base_or_member
 // A sample type that uses base_or_member, used
 // as a base for the main demonstration classes
 class base_class
 {
 public:
    explicit  base_class( base_or_member &x, base_or_member *y = 0,
     base_or_member *z = 0 );
    ~base_class();
 private:
    base_or_member  *x_, *y_, *z_;
 };  // base_class
 // This bad class demonstrates the direct method of a base class needing
 // to be initialized by a member.  This is improper since the member
 // isn't initialized until after the base class.
 class bad_class
    : public base_class
 {
 public:
     bad_class();
    ~bad_class();
 private:
    base_or_member  x_;
 };  // bad_class
 // The first good class demonstrates the correct way to initialize a
 // base class with a member.  The member is changed to another base
 // class, one that is initialized before the base that needs it.
 class good_class_1
    : private boost::base_from_member<base_or_member>
    , public base_class
 {
    typedef boost::base_from_member<base_or_member>  pbase_type;
    typedef base_class                                base_type;
 public:
     good_class_1();
    ~good_class_1();
 };  // good_class_1
 // The second good class also demonstrates the correct way to initialize
 // base classes with other subobjects.  This class uses the other helpers
 // in the library, and shows the technique of using two base subobjects
 // of the "same" type.
 class good_class_2
    : private boost::base_from_member<base_or_member, 0>
    , private boost::base_from_member<base_or_member, 1>
    , private boost::base_from_member<base_or_member, 2>
    , public base_class
 {
    typedef boost::base_from_member<base_or_member, 0>  pbase_type0;
    typedef boost::base_from_member<base_or_member, 1>  pbase_type1;
    typedef boost::base_from_member<base_or_member, 2>  pbase_type2;
    typedef base_class                                   base_type;
 public:
     good_class_2();
    ~good_class_2();
 };  // good_class_2
 // Declare/define the single object registrar
 object_registrar  obj_reg;
 // Main functionality
 int
 test_main( int , char * [] )
 {
    BOOST_CHECK( obj_reg.db_.empty() );
    BOOST_CHECK( obj_reg.defrauders_in_.empty() );
    BOOST_CHECK( obj_reg.defrauders_out_.empty() );
    BOOST_CHECK( obj_reg.overeager_.empty() );
    BOOST_CHECK( obj_reg.overkilled_.empty() );
    // Make a separate block to examine pre- and post-effects
    {
        using std::cout;
        using std::endl;
        bad_class  bc;
        BOOST_CHECK( obj_reg.db_.size() == 3 );
        BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
        good_class_1  gc1;
        BOOST_CHECK( obj_reg.db_.size() == 6 );
        BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
        good_class_2  gc2;
        BOOST_CHECK( obj_reg.db_.size() == 11 );
        BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
        BOOST_CHECK( obj_reg.defrauders_out_.empty() );
        BOOST_CHECK( obj_reg.overeager_.empty() );
        BOOST_CHECK( obj_reg.overkilled_.empty() );
        // Getting the addresses of the objects ensure
        // that they're used, and not optimized away.
        cout << "Object 'bc' is at " << &bc << '.' << endl;
        cout << "Object 'gc1' is at " << &gc1 << '.' << endl;
        cout << "Object 'gc2' is at " << &gc2 << '.' << endl;
    }
    BOOST_CHECK( obj_reg.db_.empty() );
    BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
    BOOST_CHECK( obj_reg.defrauders_out_.size() == 1 );
    BOOST_CHECK( obj_reg.overeager_.empty() );
    BOOST_CHECK( obj_reg.overkilled_.empty() );
    return boost::exit_success;
 }
 // Print an object's ID
 std::ostream &
 operator <<
 (
    std::ostream &     os,
    object_id const &  oi
 )
 {
    // I had an std::ostringstream to help, but I did not need it since
    // the program never screws around with formatting.  Worse, using
    // std::ostringstream is an issue with some compilers.
    return os << '[' << ( oi.second ? oi.second->name() : "NOTHING" )
     << " at " << oi.first << ']';
 }
 // Get an object ID given an object
 template < typename T >
 inline
 object_id
 identify
 (
    T &  obj
 )
 {
    return std::make_pair( static_cast<void *>(&obj), &(typeid( obj )) );
 }
 // Compare two object IDs
 bool
 object_id_compare::operator ()
 (
    object_id const &  a,
    object_id const &  b
 ) const
 {
    std::less<void *>  vp_cmp;
    if ( vp_cmp(a.first, b.first) )
    {
        return true;
    }
    else if ( vp_cmp(b.first, a.first) )
    {
        return false;
    }
    else
    {
        // object pointers are equal, compare the types
        if ( a.second == b.second )
        {
            return false;
        }
        else if ( !a.second )
        {
            return true;   // NULL preceeds anything else
        }
        else if ( !b.second )
        {
            return false;  // NULL preceeds anything else
        }
        else
        {
            return a.second->before( *b.second ) != 0;
        }
    }
 }
 // Let an object register its existence
 void
 object_registrar::register_object_imp
 (
    object_id  obj
 )
 {
    if ( db_.count(obj) <= 0 )
    {
        db_.insert( obj );
        #if CONTROL_EXTRA_PRINTING
        std::cout << "Registered " << obj << '.' << std::endl;
        #endif
    }
    else
    {
        overeager_.push_back( obj );
        #if CONTROL_EXTRA_PRINTING
        std::cout << "Attempted to register a non-existant " << obj
         << '.' << std::endl;
        #endif
    }
 }
 // Let an object register its use of another object
 void
 object_registrar::register_use_imp
 (
    object_id  owner,
    object_id  owned
 )
 {
    if ( db_.count(owned) > 0 )
    {
        // We don't care to record usage registrations
    }
    else
    {
        defrauders_in_.push_back( std::make_pair(owner, owned) );
        #if CONTROL_EXTRA_PRINTING
        std::cout << "Attempted to own a non-existant " << owned
         << " by " << owner << '.' << std::endl;
        #endif
    }
 }
 // Let an object un-register its use of another object
 void
 object_registrar::unregister_use_imp
 (
    object_id  owner,
    object_id  owned
 )
 {
    if ( db_.count(owned) > 0 )
    {
        // We don't care to record usage un-registrations
    }
    else
    {
        defrauders_out_.push_back( std::make_pair(owner, owned) );
        #if CONTROL_EXTRA_PRINTING
        std::cout << "Attempted to disown a non-existant " << owned
         << " by " << owner << '.' << std::endl;
        #endif
    }
 }
 // Let an object un-register its existence
 void
 object_registrar::unregister_object_imp
 (
    object_id  obj
 )
 {
    set_type::iterator const  i = db_.find( obj );
    if ( i != db_.end() )
    {
        db_.erase( i );
        #if CONTROL_EXTRA_PRINTING
        std::cout << "Unregistered " << obj << '.' << std::endl;
        #endif
    }
    else
    {
        overkilled_.push_back( obj );
        #if CONTROL_EXTRA_PRINTING
        std::cout << "Attempted to unregister a non-existant " << obj
         << '.' << std::endl;
        #endif
    }
 }
 // Macros to abstract the registration of objects
 #ifndef BOOST_NO_MEMBER_TEMPLATES
 #define PRIVATE_REGISTER_BIRTH(o)     obj_reg.register_object( (o) )
 #define PRIVATE_REGISTER_DEATH(o)     obj_reg.unregister_object( (o) )
 #define PRIVATE_REGISTER_USE(o, w)    obj_reg.register_use( (o), (w) )
 #define PRIVATE_UNREGISTER_USE(o, w)  obj_reg.unregister_use( (o), (w) )
 #else
 #define PRIVATE_REGISTER_BIRTH(o)     obj_reg.register_object_imp( \
 identify((o)) )
 #define PRIVATE_REGISTER_DEATH(o)     obj_reg.unregister_object_imp( \
 identify((o)) )
 #define PRIVATE_REGISTER_USE(o, w)    obj_reg.register_use_imp( identify((o)), \
 identify((w)) )
 #define PRIVATE_UNREGISTER_USE(o, w)  obj_reg.unregister_use_imp( \
 identify((o)), identify((w)) )
 #endif
 // Create a base_or_member, with arguments to simulate member initializations
 base_or_member::base_or_member
 (
    int     x,  // = 1
    double  y   // = -0.25
 )
 {
    PRIVATE_REGISTER_BIRTH( *this );
    #if CONTROL_EXTRA_PRINTING
    std::cout << "\tMy x-factor is " << x << " and my y-factor is " << y
     << '.' << std::endl;
    #endif
 }
 // Destroy a base_or_member
 inline
 base_or_member::~base_or_member
 (
 )
 {
    PRIVATE_REGISTER_DEATH( *this );
 }
 // Create a base_class, registering any objects used
 base_class::base_class
 (
    base_or_member &  x,
    base_or_member *  y,  // = 0
    base_or_member *  z   // = 0
 )
    : x_( &x ), y_( y ), z_( z )
 {
    PRIVATE_REGISTER_BIRTH( *this );
    #if CONTROL_EXTRA_PRINTING
    std::cout << "\tMy x-factor is " << x_;
    #endif
    PRIVATE_REGISTER_USE( *this, *x_ );
    if ( y_ )
    {
        #if CONTROL_EXTRA_PRINTING
        std::cout << ", my y-factor is " << y_;
        #endif
        PRIVATE_REGISTER_USE( *this, *y_ );
    }
    if ( z_ )
    {
        #if CONTROL_EXTRA_PRINTING
        std::cout << ", my z-factor is " << z_;
        #endif
        PRIVATE_REGISTER_USE( *this, *z_ );
    }
    #if CONTROL_EXTRA_PRINTING
    std::cout << '.' << std::endl;
    #endif
 }
 // Destroy a base_class, unregistering the objects it uses
 base_class::~base_class
 (
 )
 {
    PRIVATE_REGISTER_DEATH( *this );
    #if CONTROL_EXTRA_PRINTING
    std::cout << "\tMy x-factor was " << x_;
    #endif
    PRIVATE_UNREGISTER_USE( *this, *x_ );
    if ( y_ )
    {
        #if CONTROL_EXTRA_PRINTING
        std::cout << ", my y-factor was " << y_;
        #endif
        PRIVATE_UNREGISTER_USE( *this, *y_ );
    }
    if ( z_ )
    {
        #if CONTROL_EXTRA_PRINTING
        std::cout << ", my z-factor was " << z_;
        #endif
        PRIVATE_UNREGISTER_USE( *this, *z_ );
    }
    #if CONTROL_EXTRA_PRINTING
    std::cout << '.' << std::endl;
    #endif
 }
 // Create a bad_class, noting the improper construction order
 bad_class::bad_class
 (
 )
    : x_( -7, 16.75 ), base_class( x_ )  // this order doesn't matter
 {
    PRIVATE_REGISTER_BIRTH( *this );
    #if CONTROL_EXTRA_PRINTING
    std::cout << "\tMy factor is at " << &x_
     << " and my base is at " << static_cast<base_class *>(this) << '.'
     << std::endl;
    #endif
 }
 // Destroy a bad_class, noting the improper destruction order
 bad_class::~bad_class
 (
 )
 {
    PRIVATE_REGISTER_DEATH( *this );
    #if CONTROL_EXTRA_PRINTING
    std::cout << "\tMy factor was at " << &x_
     << " and my base was at " << static_cast<base_class *>(this)
     << '.' << std::endl;
    #endif
 }
 // Create a good_class_1, noting the proper construction order
 good_class_1::good_class_1
 (
 )
    : pbase_type( 8 ), base_type( member )
 {
    PRIVATE_REGISTER_BIRTH( *this );
    #if CONTROL_EXTRA_PRINTING
    std::cout << "\tMy factor is at " << &member
     << " and my base is at " << static_cast<base_class *>(this) << '.'
     << std::endl;
    #endif
 }
 // Destroy a good_class_1, noting the proper destruction order
 good_class_1::~good_class_1
 (
 )
 {
    PRIVATE_REGISTER_DEATH( *this );
    #if CONTROL_EXTRA_PRINTING
    std::cout << "\tMy factor was at " << &member
     << " and my base was at " << static_cast<base_class *>(this)
     << '.' << std::endl;
    #endif
 }
 // Create a good_class_2, noting the proper construction order
 good_class_2::good_class_2
 (
 )
    : pbase_type0(), pbase_type1(-16, 0.125), pbase_type2(2, -3)
    , base_type( pbase_type1::member, &this->pbase_type0::member,
       &this->pbase_type2::member )
 {
    PRIVATE_REGISTER_BIRTH( *this );
    #if CONTROL_EXTRA_PRINTING
    std::cout << "\tMy factors are at " << &this->pbase_type0::member
     << ", " << &this->pbase_type1::member << ", "
     << &this->pbase_type2::member << ", and my base is at "
     << static_cast<base_class *>(this) << '.' << std::endl;
    #endif
 }
 // Destroy a good_class_2, noting the proper destruction order
 good_class_2::~good_class_2
 (
 )
 {
    PRIVATE_REGISTER_DEATH( *this );
    #if CONTROL_EXTRA_PRINTING
    std::cout << "\tMy factors were at " << &this->pbase_type0::member
     << ", " << &this->pbase_type1::member << ", "
     << &this->pbase_type2::member << ", and my base was at "
     << static_cast<base_class *>(this) << '.' << std::endl;
    #endif
 }
--- a/binary_search_test.cpp
+++ b/binary_search_test.cpp
@ -0,0 +1,258 @@
 // (C) Copyright David Abrahams 2000.
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #include <vector>
 #include <string>
 #include <memory>
 #include <climits>
 #include <iostream>
 #include <cassert>
 #include <stdlib.h> // for rand(). Would use cstdlib but VC6.4 doesn't put it in std::
 #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
 #endif
 #ifdef USE_SSTREAM
 # include <sstream>
 #else
 # include <strstream>
 #endif
 namespace {
 // 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;
 unsigned random_number()
 {
    return static_cast<unsigned>(::rand()) % sequence_length;
 }
 # ifndef USE_SSTREAM
 class unfreezer {
 public:
    unfreezer(std::ostrstream& s) : m_stream(s) {}
    ~unfreezer() { m_stream.freeze(false); }
 private:
    std::ostrstream& m_stream;
 };
 # endif
 template <class T>
 void push_back_random_number_string(T& seq)
 {
    unsigned value = random_number();
 # if defined(__SGI_STL_PORT) ? defined(__SGI_STL_OWN_IOSTREAMS) : (!defined(__GNUC__) || __GNUC__ > 2)
    std::ostringstream s;
    s << value;
    seq.push_back(s.str());
 # else
    std::ostrstream s;
    auto unfreezer unfreeze(s);
    s << value << char(0);
    seq.push_back(std::string(s.str()));
 # endif
 }
 inline unsigned to_int(unsigned x) { return x; }
 inline unsigned to_int(const std::string& x) { return atoi(x.c_str()); }
 struct cmp
 {
    template <class A1, class A2>
    inline bool operator()(const A1& a1, const A2& a2) const
    {
        return to_int(a1) < to_int(a2);
    }
 };
 inline bool operator<(const mystring& x, const unsigned y)
 {
    return to_int(x) < y;
 }
 inline bool operator<(const unsigned y, const mystring& x)
 {
    return y < to_int(x);
 }
 template <class T>
 void sort_by_value(T& x);
 template <class T>
 void sort_by_value_(T& v, long)
 {
    std::sort(v.begin(), v.end(), cmp());
 }
 template <class T>
 void random_sorted_sequence(T& seq)
 {
    seq.clear();
    for (std::size_t i = 0; i < sequence_length; ++i)
    {
        push_back_random_number_string(seq);
    }
    sort_by_value(seq);
 }
 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()
    std::vector<T> seq;
    seq.reserve(sequence_length);
    std::copy(l.begin(), l.end(), std::back_inserter(seq));
    sort_by_value(seq);
    std::copy(seq.begin(), seq.end(), l.begin());
 # else
    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
 {
    template <class Iterator, class Key>
    static Iterator lower_bound(Iterator start, Iterator finish, Key key, Compare cmp)
        { return boost::detail::lower_bound(start, finish, key, cmp); }
    template <class Iterator, class Key>
    static Iterator upper_bound(Iterator start, Iterator finish, Key key, Compare cmp)
        { return boost::detail::upper_bound(start, finish, key, cmp); }
    template <class Iterator, class Key>
    static std::pair<Iterator, Iterator> equal_range(Iterator start, Iterator finish, Key key, Compare cmp)
        { return boost::detail::equal_range(start, finish, key, cmp); }
    template <class Iterator, class Key>
    static bool binary_search(Iterator start, Iterator finish, Key key, Compare cmp)
        { return boost::detail::binary_search(start, finish, key, cmp); }
 };
 struct no_compare {};
 template <> struct searches<no_compare>
 {
    template <class Iterator, class Key>
    static Iterator lower_bound(Iterator start, Iterator finish, Key key, no_compare)
        { return boost::detail::lower_bound(start, finish, key); }
    template <class Iterator, class Key>
    static Iterator upper_bound(Iterator start, Iterator finish, Key key, no_compare)
        { return boost::detail::upper_bound(start, finish, key); }
    template <class Iterator, class Key>
    static std::pair<Iterator, Iterator> equal_range(Iterator start, Iterator finish, Key key, no_compare)
        { return boost::detail::equal_range(start, finish, key); }
    template <class Iterator, class Key>
    static bool binary_search(Iterator start, Iterator finish, Key key, no_compare)
        { return boost::detail::binary_search(start, finish, key); }
 };
 template <class Sequence, class Compare>
 void test_loop(Sequence& x, Compare cmp, unsigned long test_count)
 {
    typedef typename Sequence::const_iterator const_iterator;
    for (unsigned long i = 0; i < test_count; ++i)
    {
        random_sorted_sequence(x);
        const const_iterator start = x.begin();
        const const_iterator finish = x.end();
        unsigned key = random_number();
        const const_iterator l = searches<Compare>::lower_bound(start, finish, key, cmp);
        const const_iterator u = searches<Compare>::upper_bound(start, finish, key, cmp);
        bool found_l = false;
        bool found_u = false;
        std::size_t index = 0;
        std::size_t count = 0;
        unsigned last_value = 0;
        for (const_iterator p = start; p != finish; ++p)
        {
            if (p == l)
                found_l = true;
            if (p == u)
            {
                assert(found_l);
                found_u = true;
            }
            unsigned value = to_int(*p);
            assert(value >= last_value);
            last_value = value;
            if (!found_l)
            {
                ++index;
                assert(to_int(*p) < key);
            }
            else if (!found_u)
            {
                ++count;
                assert(to_int(*p) == key);
            }
            else
                assert(to_int(*p) > key);
        }
        assert(found_l || l == finish);
        assert(found_u || u == finish);
        std::pair<const_iterator, const_iterator>
            range = searches<Compare>::equal_range(start, finish, key, cmp);
        assert(range.first == l);
        assert(range.second == u);
        bool found = searches<Compare>::binary_search(start, finish, key, cmp);
        assert(found == (u != l));
        std::cout << "found " << count << " copies of " << key << " at index " << index << "\n";
    }
 }
 }
 int main()
 {
    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<mystring> y;
    std::cout << "=== testing bidirectional iterators with <: ===\n";
    test_loop(y, no_compare(), 25);
    std::cout << "=== testing bidirectional iterators with compare: ===\n";
    test_loop(y, cmp(), 25);
    std::cerr << "******TEST PASSED******\n";
    return 0;
 }
--- a/binary_test.cpp
+++ b/binary_test.cpp
@ -0,0 +1,647 @@
 /*=============================================================================
    Copyright (c) 2006, 2007 Matthew Calabrese
    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #include <boost/test/minimal.hpp>
 #include <boost/utility/binary.hpp>
 #include <algorithm>
 #include <cstddef>
 #ifdef BOOST_MSVC
 #pragma warning(disable:4996) // warning C4996: 'std::equal': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators'
 #endif
 /*
 Note: This file tests every single valid bit-grouping on its own, and some
      random combinations of bit-groupings.
 */
 std::size_t const num_random_test_values = 32;
 // Note: These hex values should all correspond with the binary array below
 unsigned int const random_unsigned_ints_hex[num_random_test_values]
  = { 0x0103u, 0x77ebu, 0x5f36u, 0x1f18u, 0xc530u, 0xa73au, 0xd6f8u, 0x0919u
    , 0xfbb0u, 0x3e7cu, 0xd0e9u, 0x22c8u, 0x724eu, 0x14fau, 0xd98eu, 0x40b5
    , 0xeba0u, 0xfe50u, 0x688au, 0x1b05u, 0x5f9cu, 0xe4fcu, 0xa7b8u, 0xd3acu
    , 0x1dddu, 0xbf04u, 0x8352u, 0xe89cu, 0x7506u, 0xe767u, 0xf489u, 0xe167
    };
 unsigned int const random_unsigned_ints_binary[num_random_test_values]
  = { BOOST_BINARY( 0 00010000 0011 ), BOOST_BINARY( 0 11101 1111  101011 )
    , BOOST_BINARY( 010111 1100110 1 1 0 ), BOOST_BINARY( 000 1 11110 00 11000 )
    , BOOST_BINARY( 110 001010 0110 000 ), BOOST_BINARY( 1010 01110011 1010 )
    , BOOST_BINARY( 11 010 1 101111 1000 ), BOOST_BINARY( 0000 100100 0110 01 )
    , BOOST_BINARY( 1111 101110 11 0000 ), BOOST_BINARY( 00111110 01111100 )
    , BOOST_BINARY( 11  010 000111 01001 ), BOOST_BINARY( 00100 010110   01000 )
    , BOOST_BINARY( 01 11001001 001110 ), BOOST_BINARY( 0010 1001111 1010 )
    , BOOST_BINARY( 1101 1 00110 0 01110 ), BOOST_BINARY( 100 000 01011010 1 )
    , BOOST_BINARY( 11 1010 1110 1000 00 ), BOOST_BINARY( 11111 110010 10000 )
    , BOOST_BINARY( 01101 00010 001010 ), BOOST_BINARY( 000 11011 000001 01 )
    , BOOST_BINARY( 01 01111 1100111 00 ), BOOST_BINARY( 1 110010 0111111 00 )
    , BOOST_BINARY( 101 0011 11 01110 00 ), BOOST_BINARY( 110100 1 110101 100 )
    , BOOST_BINARY( 00 1110111 011 101 ), BOOST_BINARY( 1011 1111 00000 100 )
    , BOOST_BINARY( 1000 00110 101 0010 ), BOOST_BINARY( 1110  10001 001110 0 )
    , BOOST_BINARY( 011 1010100 000 110 ), BOOST_BINARY( 1110 0111 01100 111 )
    , BOOST_BINARY( 11110 10010 001001 ), BOOST_BINARY( 11 1000010 1100 111 )
    };
 unsigned int const unsigned_ints_1_bit[2] =
 { BOOST_BINARY( 0 )
 , BOOST_BINARY( 1 )
 };
 unsigned int const unsigned_ints_2_bits[4] =
 { BOOST_BINARY( 00 )
 , BOOST_BINARY( 01 )
 , BOOST_BINARY( 10 )
 , BOOST_BINARY( 11 )
 };
 unsigned int const unsigned_ints_3_bits[8] =
 { BOOST_BINARY( 000 )
 , BOOST_BINARY( 001 )
 , BOOST_BINARY( 010 )
 , BOOST_BINARY( 011 )
 , BOOST_BINARY( 100 )
 , BOOST_BINARY( 101 )
 , BOOST_BINARY( 110 )
 , BOOST_BINARY( 111 )
 };
 unsigned int const unsigned_ints_4_bits[16] =
 { BOOST_BINARY( 0000 )
 , BOOST_BINARY( 0001 )
 , BOOST_BINARY( 0010 )
 , BOOST_BINARY( 0011 )
 , BOOST_BINARY( 0100 )
 , BOOST_BINARY( 0101 )
 , BOOST_BINARY( 0110 )
 , BOOST_BINARY( 0111 )
 , BOOST_BINARY( 1000 )
 , BOOST_BINARY( 1001 )
 , BOOST_BINARY( 1010 )
 , BOOST_BINARY( 1011 )
 , BOOST_BINARY( 1100 )
 , BOOST_BINARY( 1101 )
 , BOOST_BINARY( 1110 )
 , BOOST_BINARY( 1111 )
 };
 unsigned int const unsigned_ints_5_bits[32] =
 { BOOST_BINARY( 00000 )
 , BOOST_BINARY( 00001 )
 , BOOST_BINARY( 00010 )
 , BOOST_BINARY( 00011 )
 , BOOST_BINARY( 00100 )
 , BOOST_BINARY( 00101 )
 , BOOST_BINARY( 00110 )
 , BOOST_BINARY( 00111 )
 , BOOST_BINARY( 01000 )
 , BOOST_BINARY( 01001 )
 , BOOST_BINARY( 01010 )
 , BOOST_BINARY( 01011 )
 , BOOST_BINARY( 01100 )
 , BOOST_BINARY( 01101 )
 , BOOST_BINARY( 01110 )
 , BOOST_BINARY( 01111 )
 , BOOST_BINARY( 10000 )
 , BOOST_BINARY( 10001 )
 , BOOST_BINARY( 10010 )
 , BOOST_BINARY( 10011 )
 , BOOST_BINARY( 10100 )
 , BOOST_BINARY( 10101 )
 , BOOST_BINARY( 10110 )
 , BOOST_BINARY( 10111 )
 , BOOST_BINARY( 11000 )
 , BOOST_BINARY( 11001 )
 , BOOST_BINARY( 11010 )
 , BOOST_BINARY( 11011 )
 , BOOST_BINARY( 11100 )
 , BOOST_BINARY( 11101 )
 , BOOST_BINARY( 11110 )
 , BOOST_BINARY( 11111 )
 };
 unsigned int const unsigned_ints_6_bits[64] =
 { BOOST_BINARY( 000000 )
 , BOOST_BINARY( 000001 )
 , BOOST_BINARY( 000010 )
 , BOOST_BINARY( 000011 )
 , BOOST_BINARY( 000100 )
 , BOOST_BINARY( 000101 )
 , BOOST_BINARY( 000110 )
 , BOOST_BINARY( 000111 )
 , BOOST_BINARY( 001000 )
 , BOOST_BINARY( 001001 )
 , BOOST_BINARY( 001010 )
 , BOOST_BINARY( 001011 )
 , BOOST_BINARY( 001100 )
 , BOOST_BINARY( 001101 )
 , BOOST_BINARY( 001110 )
 , BOOST_BINARY( 001111 )
 , BOOST_BINARY( 010000 )
 , BOOST_BINARY( 010001 )
 , BOOST_BINARY( 010010 )
 , BOOST_BINARY( 010011 )
 , BOOST_BINARY( 010100 )
 , BOOST_BINARY( 010101 )
 , BOOST_BINARY( 010110 )
 , BOOST_BINARY( 010111 )
 , BOOST_BINARY( 011000 )
 , BOOST_BINARY( 011001 )
 , BOOST_BINARY( 011010 )
 , BOOST_BINARY( 011011 )
 , BOOST_BINARY( 011100 )
 , BOOST_BINARY( 011101 )
 , BOOST_BINARY( 011110 )
 , BOOST_BINARY( 011111 )
 , BOOST_BINARY( 100000 )
 , BOOST_BINARY( 100001 )
 , BOOST_BINARY( 100010 )
 , BOOST_BINARY( 100011 )
 , BOOST_BINARY( 100100 )
 , BOOST_BINARY( 100101 )
 , BOOST_BINARY( 100110 )
 , BOOST_BINARY( 100111 )
 , BOOST_BINARY( 101000 )
 , BOOST_BINARY( 101001 )
 , BOOST_BINARY( 101010 )
 , BOOST_BINARY( 101011 )
 , BOOST_BINARY( 101100 )
 , BOOST_BINARY( 101101 )
 , BOOST_BINARY( 101110 )
 , BOOST_BINARY( 101111 )
 , BOOST_BINARY( 110000 )
 , BOOST_BINARY( 110001 )
 , BOOST_BINARY( 110010 )
 , BOOST_BINARY( 110011 )
 , BOOST_BINARY( 110100 )
 , BOOST_BINARY( 110101 )
 , BOOST_BINARY( 110110 )
 , BOOST_BINARY( 110111 )
 , BOOST_BINARY( 111000 )
 , BOOST_BINARY( 111001 )
 , BOOST_BINARY( 111010 )
 , BOOST_BINARY( 111011 )
 , BOOST_BINARY( 111100 )
 , BOOST_BINARY( 111101 )
 , BOOST_BINARY( 111110 )
 , BOOST_BINARY( 111111 )
 };
 unsigned int const unsigned_ints_7_bits[128] =
 { BOOST_BINARY( 0000000 )
 , BOOST_BINARY( 0000001 )
 , BOOST_BINARY( 0000010 )
 , BOOST_BINARY( 0000011 )
 , BOOST_BINARY( 0000100 )
 , BOOST_BINARY( 0000101 )
 , BOOST_BINARY( 0000110 )
 , BOOST_BINARY( 0000111 )
 , BOOST_BINARY( 0001000 )
 , BOOST_BINARY( 0001001 )
 , BOOST_BINARY( 0001010 )
 , BOOST_BINARY( 0001011 )
 , BOOST_BINARY( 0001100 )
 , BOOST_BINARY( 0001101 )
 , BOOST_BINARY( 0001110 )
 , BOOST_BINARY( 0001111 )
 , BOOST_BINARY( 0010000 )
 , BOOST_BINARY( 0010001 )
 , BOOST_BINARY( 0010010 )
 , BOOST_BINARY( 0010011 )
 , BOOST_BINARY( 0010100 )
 , BOOST_BINARY( 0010101 )
 , BOOST_BINARY( 0010110 )
 , BOOST_BINARY( 0010111 )
 , BOOST_BINARY( 0011000 )
 , BOOST_BINARY( 0011001 )
 , BOOST_BINARY( 0011010 )
 , BOOST_BINARY( 0011011 )
 , BOOST_BINARY( 0011100 )
 , BOOST_BINARY( 0011101 )
 , BOOST_BINARY( 0011110 )
 , BOOST_BINARY( 0011111 )
 , BOOST_BINARY( 0100000 )
 , BOOST_BINARY( 0100001 )
 , BOOST_BINARY( 0100010 )
 , BOOST_BINARY( 0100011 )
 , BOOST_BINARY( 0100100 )
 , BOOST_BINARY( 0100101 )
 , BOOST_BINARY( 0100110 )
 , BOOST_BINARY( 0100111 )
 , BOOST_BINARY( 0101000 )
 , BOOST_BINARY( 0101001 )
 , BOOST_BINARY( 0101010 )
 , BOOST_BINARY( 0101011 )
 , BOOST_BINARY( 0101100 )
 , BOOST_BINARY( 0101101 )
 , BOOST_BINARY( 0101110 )
 , BOOST_BINARY( 0101111 )
 , BOOST_BINARY( 0110000 )
 , BOOST_BINARY( 0110001 )
 , BOOST_BINARY( 0110010 )
 , BOOST_BINARY( 0110011 )
 , BOOST_BINARY( 0110100 )
 , BOOST_BINARY( 0110101 )
 , BOOST_BINARY( 0110110 )
 , BOOST_BINARY( 0110111 )
 , BOOST_BINARY( 0111000 )
 , BOOST_BINARY( 0111001 )
 , BOOST_BINARY( 0111010 )
 , BOOST_BINARY( 0111011 )
 , BOOST_BINARY( 0111100 )
 , BOOST_BINARY( 0111101 )
 , BOOST_BINARY( 0111110 )
 , BOOST_BINARY( 0111111 )
 , BOOST_BINARY( 1000000 )
 , BOOST_BINARY( 1000001 )
 , BOOST_BINARY( 1000010 )
 , BOOST_BINARY( 1000011 )
 , BOOST_BINARY( 1000100 )
 , BOOST_BINARY( 1000101 )
 , BOOST_BINARY( 1000110 )
 , BOOST_BINARY( 1000111 )
 , BOOST_BINARY( 1001000 )
 , BOOST_BINARY( 1001001 )
 , BOOST_BINARY( 1001010 )
 , BOOST_BINARY( 1001011 )
 , BOOST_BINARY( 1001100 )
 , BOOST_BINARY( 1001101 )
 , BOOST_BINARY( 1001110 )
 , BOOST_BINARY( 1001111 )
 , BOOST_BINARY( 1010000 )
 , BOOST_BINARY( 1010001 )
 , BOOST_BINARY( 1010010 )
 , BOOST_BINARY( 1010011 )
 , BOOST_BINARY( 1010100 )
 , BOOST_BINARY( 1010101 )
 , BOOST_BINARY( 1010110 )
 , BOOST_BINARY( 1010111 )
 , BOOST_BINARY( 1011000 )
 , BOOST_BINARY( 1011001 )
 , BOOST_BINARY( 1011010 )
 , BOOST_BINARY( 1011011 )
 , BOOST_BINARY( 1011100 )
 , BOOST_BINARY( 1011101 )
 , BOOST_BINARY( 1011110 )
 , BOOST_BINARY( 1011111 )
 , BOOST_BINARY( 1100000 )
 , BOOST_BINARY( 1100001 )
 , BOOST_BINARY( 1100010 )
 , BOOST_BINARY( 1100011 )
 , BOOST_BINARY( 1100100 )
 , BOOST_BINARY( 1100101 )
 , BOOST_BINARY( 1100110 )
 , BOOST_BINARY( 1100111 )
 , BOOST_BINARY( 1101000 )
 , BOOST_BINARY( 1101001 )
 , BOOST_BINARY( 1101010 )
 , BOOST_BINARY( 1101011 )
 , BOOST_BINARY( 1101100 )
 , BOOST_BINARY( 1101101 )
 , BOOST_BINARY( 1101110 )
 , BOOST_BINARY( 1101111 )
 , BOOST_BINARY( 1110000 )
 , BOOST_BINARY( 1110001 )
 , BOOST_BINARY( 1110010 )
 , BOOST_BINARY( 1110011 )
 , BOOST_BINARY( 1110100 )
 , BOOST_BINARY( 1110101 )
 , BOOST_BINARY( 1110110 )
 , BOOST_BINARY( 1110111 )
 , BOOST_BINARY( 1111000 )
 , BOOST_BINARY( 1111001 )
 , BOOST_BINARY( 1111010 )
 , BOOST_BINARY( 1111011 )
 , BOOST_BINARY( 1111100 )
 , BOOST_BINARY( 1111101 )
 , BOOST_BINARY( 1111110 )
 , BOOST_BINARY( 1111111 )
 };
 unsigned int const unsigned_ints_8_bits[256] =
 { BOOST_BINARY( 00000000 )
 , BOOST_BINARY( 00000001 )
 , BOOST_BINARY( 00000010 )
 , BOOST_BINARY( 00000011 )
 , BOOST_BINARY( 00000100 )
 , BOOST_BINARY( 00000101 )
 , BOOST_BINARY( 00000110 )
 , BOOST_BINARY( 00000111 )
 , BOOST_BINARY( 00001000 )
 , BOOST_BINARY( 00001001 )
 , BOOST_BINARY( 00001010 )
 , BOOST_BINARY( 00001011 )
 , BOOST_BINARY( 00001100 )
 , BOOST_BINARY( 00001101 )
 , BOOST_BINARY( 00001110 )
 , BOOST_BINARY( 00001111 )
 , BOOST_BINARY( 00010000 )
 , BOOST_BINARY( 00010001 )
 , BOOST_BINARY( 00010010 )
 , BOOST_BINARY( 00010011 )
 , BOOST_BINARY( 00010100 )
 , BOOST_BINARY( 00010101 )
 , BOOST_BINARY( 00010110 )
 , BOOST_BINARY( 00010111 )
 , BOOST_BINARY( 00011000 )
 , BOOST_BINARY( 00011001 )
 , BOOST_BINARY( 00011010 )
 , BOOST_BINARY( 00011011 )
 , BOOST_BINARY( 00011100 )
 , BOOST_BINARY( 00011101 )
 , BOOST_BINARY( 00011110 )
 , BOOST_BINARY( 00011111 )
 , BOOST_BINARY( 00100000 )
 , BOOST_BINARY( 00100001 )
 , BOOST_BINARY( 00100010 )
 , BOOST_BINARY( 00100011 )
 , BOOST_BINARY( 00100100 )
 , BOOST_BINARY( 00100101 )
 , BOOST_BINARY( 00100110 )
 , BOOST_BINARY( 00100111 )
 , BOOST_BINARY( 00101000 )
 , BOOST_BINARY( 00101001 )
 , BOOST_BINARY( 00101010 )
 , BOOST_BINARY( 00101011 )
 , BOOST_BINARY( 00101100 )
 , BOOST_BINARY( 00101101 )
 , BOOST_BINARY( 00101110 )
 , BOOST_BINARY( 00101111 )
 , BOOST_BINARY( 00110000 )
 , BOOST_BINARY( 00110001 )
 , BOOST_BINARY( 00110010 )
 , BOOST_BINARY( 00110011 )
 , BOOST_BINARY( 00110100 )
 , BOOST_BINARY( 00110101 )
 , BOOST_BINARY( 00110110 )
 , BOOST_BINARY( 00110111 )
 , BOOST_BINARY( 00111000 )
 , BOOST_BINARY( 00111001 )
 , BOOST_BINARY( 00111010 )
 , BOOST_BINARY( 00111011 )
 , BOOST_BINARY( 00111100 )
 , BOOST_BINARY( 00111101 )
 , BOOST_BINARY( 00111110 )
 , BOOST_BINARY( 00111111 )
 , BOOST_BINARY( 01000000 )
 , BOOST_BINARY( 01000001 )
 , BOOST_BINARY( 01000010 )
 , BOOST_BINARY( 01000011 )
 , BOOST_BINARY( 01000100 )
 , BOOST_BINARY( 01000101 )
 , BOOST_BINARY( 01000110 )
 , BOOST_BINARY( 01000111 )
 , BOOST_BINARY( 01001000 )
 , BOOST_BINARY( 01001001 )
 , BOOST_BINARY( 01001010 )
 , BOOST_BINARY( 01001011 )
 , BOOST_BINARY( 01001100 )
 , BOOST_BINARY( 01001101 )
 , BOOST_BINARY( 01001110 )
 , BOOST_BINARY( 01001111 )
 , BOOST_BINARY( 01010000 )
 , BOOST_BINARY( 01010001 )
 , BOOST_BINARY( 01010010 )
 , BOOST_BINARY( 01010011 )
 , BOOST_BINARY( 01010100 )
 , BOOST_BINARY( 01010101 )
 , BOOST_BINARY( 01010110 )
 , BOOST_BINARY( 01010111 )
 , BOOST_BINARY( 01011000 )
 , BOOST_BINARY( 01011001 )
 , BOOST_BINARY( 01011010 )
 , BOOST_BINARY( 01011011 )
 , BOOST_BINARY( 01011100 )
 , BOOST_BINARY( 01011101 )
 , BOOST_BINARY( 01011110 )
 , BOOST_BINARY( 01011111 )
 , BOOST_BINARY( 01100000 )
 , BOOST_BINARY( 01100001 )
 , BOOST_BINARY( 01100010 )
 , BOOST_BINARY( 01100011 )
 , BOOST_BINARY( 01100100 )
 , BOOST_BINARY( 01100101 )
 , BOOST_BINARY( 01100110 )
 , BOOST_BINARY( 01100111 )
 , BOOST_BINARY( 01101000 )
 , BOOST_BINARY( 01101001 )
 , BOOST_BINARY( 01101010 )
 , BOOST_BINARY( 01101011 )
 , BOOST_BINARY( 01101100 )
 , BOOST_BINARY( 01101101 )
 , BOOST_BINARY( 01101110 )
 , BOOST_BINARY( 01101111 )
 , BOOST_BINARY( 01110000 )
 , BOOST_BINARY( 01110001 )
 , BOOST_BINARY( 01110010 )
 , BOOST_BINARY( 01110011 )
 , BOOST_BINARY( 01110100 )
 , BOOST_BINARY( 01110101 )
 , BOOST_BINARY( 01110110 )
 , BOOST_BINARY( 01110111 )
 , BOOST_BINARY( 01111000 )
 , BOOST_BINARY( 01111001 )
 , BOOST_BINARY( 01111010 )
 , BOOST_BINARY( 01111011 )
 , BOOST_BINARY( 01111100 )
 , BOOST_BINARY( 01111101 )
 , BOOST_BINARY( 01111110 )
 , BOOST_BINARY( 01111111 )
 , BOOST_BINARY( 10000000 )
 , BOOST_BINARY( 10000001 )
 , BOOST_BINARY( 10000010 )
 , BOOST_BINARY( 10000011 )
 , BOOST_BINARY( 10000100 )
 , BOOST_BINARY( 10000101 )
 , BOOST_BINARY( 10000110 )
 , BOOST_BINARY( 10000111 )
 , BOOST_BINARY( 10001000 )
 , BOOST_BINARY( 10001001 )
 , BOOST_BINARY( 10001010 )
 , BOOST_BINARY( 10001011 )
 , BOOST_BINARY( 10001100 )
 , BOOST_BINARY( 10001101 )
 , BOOST_BINARY( 10001110 )
 , BOOST_BINARY( 10001111 )
 , BOOST_BINARY( 10010000 )
 , BOOST_BINARY( 10010001 )
 , BOOST_BINARY( 10010010 )
 , BOOST_BINARY( 10010011 )
 , BOOST_BINARY( 10010100 )
 , BOOST_BINARY( 10010101 )
 , BOOST_BINARY( 10010110 )
 , BOOST_BINARY( 10010111 )
 , BOOST_BINARY( 10011000 )
 , BOOST_BINARY( 10011001 )
 , BOOST_BINARY( 10011010 )
 , BOOST_BINARY( 10011011 )
 , BOOST_BINARY( 10011100 )
 , BOOST_BINARY( 10011101 )
 , BOOST_BINARY( 10011110 )
 , BOOST_BINARY( 10011111 )
 , BOOST_BINARY( 10100000 )
 , BOOST_BINARY( 10100001 )
 , BOOST_BINARY( 10100010 )
 , BOOST_BINARY( 10100011 )
 , BOOST_BINARY( 10100100 )
 , BOOST_BINARY( 10100101 )
 , BOOST_BINARY( 10100110 )
 , BOOST_BINARY( 10100111 )
 , BOOST_BINARY( 10101000 )
 , BOOST_BINARY( 10101001 )
 , BOOST_BINARY( 10101010 )
 , BOOST_BINARY( 10101011 )
 , BOOST_BINARY( 10101100 )
 , BOOST_BINARY( 10101101 )
 , BOOST_BINARY( 10101110 )
 , BOOST_BINARY( 10101111 )
 , BOOST_BINARY( 10110000 )
 , BOOST_BINARY( 10110001 )
 , BOOST_BINARY( 10110010 )
 , BOOST_BINARY( 10110011 )
 , BOOST_BINARY( 10110100 )
 , BOOST_BINARY( 10110101 )
 , BOOST_BINARY( 10110110 )
 , BOOST_BINARY( 10110111 )
 , BOOST_BINARY( 10111000 )
 , BOOST_BINARY( 10111001 )
 , BOOST_BINARY( 10111010 )
 , BOOST_BINARY( 10111011 )
 , BOOST_BINARY( 10111100 )
 , BOOST_BINARY( 10111101 )
 , BOOST_BINARY( 10111110 )
 , BOOST_BINARY( 10111111 )
 , BOOST_BINARY( 11000000 )
 , BOOST_BINARY( 11000001 )
 , BOOST_BINARY( 11000010 )
 , BOOST_BINARY( 11000011 )
 , BOOST_BINARY( 11000100 )
 , BOOST_BINARY( 11000101 )
 , BOOST_BINARY( 11000110 )
 , BOOST_BINARY( 11000111 )
 , BOOST_BINARY( 11001000 )
 , BOOST_BINARY( 11001001 )
 , BOOST_BINARY( 11001010 )
 , BOOST_BINARY( 11001011 )
 , BOOST_BINARY( 11001100 )
 , BOOST_BINARY( 11001101 )
 , BOOST_BINARY( 11001110 )
 , BOOST_BINARY( 11001111 )
 , BOOST_BINARY( 11010000 )
 , BOOST_BINARY( 11010001 )
 , BOOST_BINARY( 11010010 )
 , BOOST_BINARY( 11010011 )
 , BOOST_BINARY( 11010100 )
 , BOOST_BINARY( 11010101 )
 , BOOST_BINARY( 11010110 )
 , BOOST_BINARY( 11010111 )
 , BOOST_BINARY( 11011000 )
 , BOOST_BINARY( 11011001 )
 , BOOST_BINARY( 11011010 )
 , BOOST_BINARY( 11011011 )
 , BOOST_BINARY( 11011100 )
 , BOOST_BINARY( 11011101 )
 , BOOST_BINARY( 11011110 )
 , BOOST_BINARY( 11011111 )
 , BOOST_BINARY( 11100000 )
 , BOOST_BINARY( 11100001 )
 , BOOST_BINARY( 11100010 )
 , BOOST_BINARY( 11100011 )
 , BOOST_BINARY( 11100100 )
 , BOOST_BINARY( 11100101 )
 , BOOST_BINARY( 11100110 )
 , BOOST_BINARY( 11100111 )
 , BOOST_BINARY( 11101000 )
 , BOOST_BINARY( 11101001 )
 , BOOST_BINARY( 11101010 )
 , BOOST_BINARY( 11101011 )
 , BOOST_BINARY( 11101100 )
 , BOOST_BINARY( 11101101 )
 , BOOST_BINARY( 11101110 )
 , BOOST_BINARY( 11101111 )
 , BOOST_BINARY( 11110000 )
 , BOOST_BINARY( 11110001 )
 , BOOST_BINARY( 11110010 )
 , BOOST_BINARY( 11110011 )
 , BOOST_BINARY( 11110100 )
 , BOOST_BINARY( 11110101 )
 , BOOST_BINARY( 11110110 )
 , BOOST_BINARY( 11110111 )
 , BOOST_BINARY( 11111000 )
 , BOOST_BINARY( 11111001 )
 , BOOST_BINARY( 11111010 )
 , BOOST_BINARY( 11111011 )
 , BOOST_BINARY( 11111100 )
 , BOOST_BINARY( 11111101 )
 , BOOST_BINARY( 11111110 )
 , BOOST_BINARY( 11111111 )
 };
 struct left_is_not_one_less_than_right
 {
  bool operator ()( unsigned int left, unsigned int right ) const
  {
    return right != left + 1;
  }
 };
 template< std::size_t Size >
 bool is_ascending_from_0_array( unsigned int const (&array)[Size] )
 {
  unsigned int const* const curr = array,
                    * const end  = array + Size;
  return    ( *curr == 0 )
         && (    std::adjacent_find( curr, end
                                   , left_is_not_one_less_than_right()
                                   )
              == end
            );
 }
 std::size_t const unsigned_int_id = 1,
                  unsigned_long_int_id = 2;
 typedef char (&unsigned_int_id_type)[unsigned_int_id];
 typedef char (&unsigned_long_int_id_type)[unsigned_long_int_id];
 // Note: Functions only used for type checking
 unsigned_int_id_type      binary_type_checker( unsigned int );
 unsigned_long_int_id_type binary_type_checker( unsigned long int );
 int test_main( int, char *[] )
 {
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_1_bit ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_2_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_3_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_4_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_5_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_6_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_7_bits ) );
  BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_8_bits ) );
  BOOST_CHECK( std::equal( &random_unsigned_ints_hex[0]
                         , random_unsigned_ints_hex + num_random_test_values
                         , &random_unsigned_ints_binary[0]
                         )
             );
  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_U( 110100 1010 ) ) )
               == unsigned_int_id
             );
  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_UL( 11110 ) ) )
               == unsigned_long_int_id
             );
  BOOST_CHECK(    sizeof( binary_type_checker( BOOST_BINARY_LU( 10 0001 ) ) )
               == unsigned_long_int_id
             );
  return 0;
 }
--- a/c++_type_traits.htm
+++ b/c++_type_traits.htm
@ -1,489 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>C++ Type traits</title>
 </head>
 <body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
 <h2 align="center">C++ Type traits</h2>
 <p align="center"><em>by John Maddock and Steve Cleary</em></p>
 <p align="center"><em>This is a draft of an article that will appear in a future
 issue of </em><a href="http://www.ddj.com"><em>Dr Dobb's Journal</em></a></p>
 <p>Generic programming (writing code which works with any data type meeting a
 set of requirements) has become the method of choice for providing reusable
 code. However, there are times in generic programming when &quot;generic&quot;
 just isn't good enough - sometimes the differences between types are too large
 for an efficient generic implementation. This is when the traits technique
 becomes important - by encapsulating those properties that need to be considered
 on a type by type basis inside a traits class, we can minimise the amount of
 code that has to differ from one type to another, and maximise the amount of
 generic code.</p>
 <p>Consider an example: when working with character strings, one common
 operation is to determine the length of a null terminated string. Clearly it's
 possible to write generic code that can do this, but it turns out that there are
 much more efficient methods available: for example, the C library functions <font size="2" face="Courier New">strlen</font>
 and <font size="2" face="Courier New">wcslen</font> are usually written in
 assembler, and with suitable hardware support can be considerably faster than a
 generic version written in C++. The authors of the C++ standard library realised
 this, and abstracted the properties of <font size="2" face="Courier New">char</font>
 and <font size="2" face="Courier New">wchar_t</font> into the class <font size="2" face="Courier New">char_traits</font>.
 Generic code that works with character strings can simply use <font size="2" face="Courier New">char_traits&lt;&gt;::length</font>
 to determine the length of a null terminated string, safe in the knowledge that
 specialisations of <font size="2" face="Courier New">char_traits</font> will use
 the most appropriate method available to them.</p>
 <h4>Type traits</h4>
 <p>Class <font size="2" face="Courier New">char_traits</font> is a classic
 example of a collection of type specific properties wrapped up in a single class
 - what Nathan Myers termed a <i>baggage class</i>[1]. In the Boost type-traits
 library, we[2] have written a set of very specific traits classes, each of which
 encapsulate a single trait from the C++ type system; for example, is a type a
 pointer or a reference type? Or does a type have a trivial constructor, or a
 const-qualifier? The type-traits classes share a unified design: each class has
 a single member <i>value</i>, a compile-time constant that is true if the type
 has the specified property, and false otherwise. As we will show, these classes
 can be used in generic programming to determine the properties of a given type
 and introduce optimisations that are appropriate for that case.</p>
 <p>The type-traits library also contains a set of classes that perform a
 specific transformation on a type; for example, they can remove a top-level
 const or volatile qualifier from a type. Each class that performs a
 transformation defines a single typedef-member <i>type</i> that is the result of
 the transformation. All of the type-traits classes are defined inside namespace <font size="2" face="Courier New">boost</font>;
 for brevity, namespace-qualification is omitted in most of the code samples
 given.</p>
 <h4>Implementation</h4>
 <p>There are far too many separate classes contained in the type-traits library
 to give a full implementation here - see the source code in the Boost library
 for the full details - however, most of the implementation is fairly repetitive
 anyway, so here we will just give you a flavour for how some of the classes are
 implemented. Beginning with possibly the simplest class in the library, is_void&lt;T&gt;
 has a member <i>value</i> that is true only if T is void.</p>
 <pre>template &lt;typename T&gt; 
 struct is_void
 { static const bool value = false; };
 template &lt;&gt; 
 struct is_void&lt;void&gt;
 { static const bool value = true; };</pre>
 <p>Here we define a primary version of the template class <font size="2" face="Courier New">is_void</font>,
 and provide a full-specialisation when T is void. While full specialisation of a
 template class is an important technique, sometimes we need a solution that is
 halfway between a fully generic solution, and a full specialisation. This is
 exactly the situation for which the standards committee defined partial
 template-class specialisation. As an example, consider the class
 boost::is_pointer&lt;T&gt;: here we needed a primary version that handles all
 the cases where T is not a pointer, and a partial specialisation to handle all
 the cases where T is a pointer:</p>
 <pre>template &lt;typename T&gt; 
 struct is_pointer 
 { static const bool value = false; };
 template &lt;typename T&gt; 
 struct is_pointer&lt;T*&gt; 
 { static const bool value = true; };</pre>
 <p>The syntax for partial specialisation is somewhat arcane and could easily
 occupy an article in its own right; like full specialisation, in order to write
 a partial specialisation for a class, you must first declare the primary
 template. The partial specialisation contains an extra &lt;<EFBFBD>&gt; after the
 class name that contains the partial specialisation parameters; these define the
 types that will bind to that partial specialisation rather than the default
 template. The rules for what can appear in a partial specialisation are somewhat
 convoluted, but as a rule of thumb if you can legally write two function
 overloads of the form:</p>
 <pre>void foo(T);
 void foo(U);</pre>
 <p>Then you can also write a partial specialisation of the form:</p>
 <pre>template &lt;typename T&gt;
 class c{ /*details*/ };
 template &lt;typename T&gt;
 class c&lt;U&gt;{ /*details*/ };</pre>
 <p>This rule is by no means foolproof, but it is reasonably simple to remember
 and close enough to the actual rule to be useful for everyday use.</p>
 <p>As a more complex example of partial specialisation consider the class
 remove_bounds&lt;T&gt;. This class defines a single typedef-member <i>type</i>
 that is the same type as T but with any top-level array bounds removed; this is
 an example of a traits class that performs a transformation on a type:</p>
 <pre>template &lt;typename T&gt; 
 struct remove_bounds
 { typedef T type; };
 template &lt;typename T, std::size_t N&gt; 
 struct remove_bounds&lt;T[N]&gt;
 { typedef T type; };</pre>
 <p>The aim of remove_bounds is this: imagine a generic algorithm that is passed
 an array type as a template parameter, <font size="2" face="Courier New">remove_bounds</font>
 provides a means of determining the underlying type of the array. For example <code>remove_bounds&lt;int[4][5]&gt;::type</code>
 would evaluate to the type <code>int[5]</code>. This example also shows that the
 number of template parameters in a partial specialisation does not have to match
 the number in the default template. However, the number of parameters that
 appear after the class name do have to match the number and type of the
 parameters in the default template.</p>
 <h4>Optimised copy</h4>
 <p>As an example of how the type traits classes can be used, consider the
 standard library algorithm copy:</p>
 <pre>template&lt;typename Iter1, typename Iter2&gt;
 Iter2 copy(Iter1 first, Iter1 last, Iter2 out);</pre>
 <p>Obviously, there's no problem writing a generic version of copy that works
 for all iterator types Iter1 and Iter2; however, there are some circumstances
 when the copy operation can best be performed by a call to <font size="2" face="Courier New">memcpy</font>.
 In order to implement copy in terms of <font size="2" face="Courier New">memcpy</font>
 all of the following conditions need to be met:</p>
 <ul>
  <li>Both of the iterator types Iter1 and Iter2 must be pointers.</li>
  <li>Both Iter1 and Iter2 must point to the same type - excluding <font size="2" face="Courier New">const</font>
    and <font size="2" face="Courier New">volatile</font>-qualifiers.</li>
  <li>The type pointed to by Iter1 must have a trivial assignment operator.</li>
 </ul>
 <p>By trivial assignment operator we mean that the type is either a scalar
 type[3] or:</p>
 <ul>
  <li>The type has no user defined assignment operator.</li>
  <li>The type does not have any data members that are references.</li>
  <li>All base classes, and all data member objects must have trivial assignment
    operators.</li>
 </ul>
 <p>If all these conditions are met then a type can be copied using <font size="2" face="Courier New">memcpy</font>
 rather than using a compiler generated assignment operator. The type-traits
 library provides a class <i>has_trivial_assign</i>, such that <code>has_trivial_assign&lt;T&gt;::value</code>
 is true only if T has a trivial assignment operator. This class &quot;just
 works&quot; for scalar types, but has to be explicitly specialised for
 class/struct types that also happen to have a trivial assignment operator. In
 other words if <i>has_trivial_assign</i> gives the wrong answer, it will give
 the &quot;safe&quot; wrong answer - that trivial assignment is not allowable.</p>
 <p>The code for an optimised version of copy that uses <font size="2" face="Courier New">memcpy</font>
 where appropriate is given in listing 1. The code begins by defining a template
 class <i>copier</i>, that takes a single Boolean template parameter, and has a
 static template member function <font size="2" face="Courier New">do_copy</font>
 which performs the generic version of <font size="2">copy</font> (in other words
 the &quot;slow but safe version&quot;). Following that there is a specialisation
 for <i>copier&lt;true&gt;</i>: again this defines a static template member
 function <font size="2" face="Courier New">do_copy</font>, but this version uses
 memcpy to perform an &quot;optimised&quot; copy.</p>
 <p>In order to complete the implementation, what we need now is a version of
 copy, that calls <code>copier&lt;true&gt;::do_copy</code> if it is safe to use <font size="2" face="Courier New">memcpy</font>,
 and otherwise calls <code>copier&lt;false&gt;::do_copy</code> to do a
 &quot;generic&quot; copy. This is what the version in listing 1 does. To
 understand how the code works look at the code for <font size="2" face="Courier New">copy</font>
 and consider first the two typedefs <i>v1_t</i> and <i>v2_t</i>. These use <code>std::iterator_traits&lt;Iter1&gt;::value_type</code>
 to determine what type the two iterators point to, and then feed the result into
 another type-traits class <i>remove_cv</i> that removes the top-level
 const-volatile-qualifiers: this will allow copy to compare the two types without
 regard to const- or volatile-qualifiers. Next, <font size="2" face="Courier New">copy</font>
 declares an enumerated value <i>can_opt</i> that will become the template
 parameter to copier - declaring this here as a constant is really just a
 convenience - the value could be passed directly to class <font size="2" face="Courier New">copier</font>.
 The value of <i>can_opt</i> is computed by verifying that all of the following
 are true:</p>
 <ul>
  <li>first that the two iterators point to the same type by using a type-traits
    class <i>is_same</i>.</li>
  <li>Then that both iterators are real pointers - using the class <i>is_pointer</i>
    described above.</li>
  <li>Finally that the pointed-to types have a trivial assignment operator using
    <i>has_trivial_assign</i>.</li>
 </ul>
 <p>Finally we can use the value of <i>can_opt</i> as the template argument to
 copier - this version of copy will now adapt to whatever parameters are passed
 to it, if its possible to use <font size="2" face="Courier New">memcpy</font>,
 then it will do so, otherwise it will use a generic copy.</p>
 <h4>Was it worth it?</h4>
 <p>It has often been repeated in these columns that &quot;premature optimisation
 is the root of all evil&quot; [4]. So the question must be asked: was our
 optimisation premature? To put this in perspective the timings for our version
 of copy compared a conventional generic copy[5] are shown in table 1.</p>
 <p>Clearly the optimisation makes a difference in this case; but, to be fair,
 the timings are loaded to exclude cache miss effects - without this accurate
 comparison between algorithms becomes difficult. However, perhaps we can add a
 couple of caveats to the premature optimisation rule:</p>
 <ul>
  <li>If you use the right algorithm for the job in the first place then
    optimisation will not be required; in some cases, <font size="2" face="Courier New">memcpy</font>
    is the right algorithm.</li>
  <li>If a component is going to be reused in many places by many people then
    optimisations may well be worthwhile where they would not be so for a single
    case - in other words, the likelihood that the optimisation will be
    absolutely necessary somewhere, sometime is that much higher. Just as
    importantly the perceived value of the stock implementation will be higher:
    there is no point standardising an algorithm if users reject it on the
    grounds that there are better, more heavily optimised versions available.</li>
 </ul>
 <h4>Table 1: Time taken to copy 1000 elements using copy&lt;const T*, T*&gt;
 (times in micro-seconds)</h4>
 <table border="1" cellpadding="7" cellspacing="1" width="529">
  <tr>
    <td valign="top" width="33%">
      <p align="center">Version</p>
    </td>
    <td valign="top" width="33%">
      <p align="center">T</p>
    </td>
    <td valign="top" width="33%">
      <p align="center">Time</p>
    </td>
  </tr>
  <tr>
    <td valign="top" width="33%">&quot;Optimised&quot; copy</td>
    <td valign="top" width="33%">char</td>
    <td valign="top" width="33%">0.99</td>
  </tr>
  <tr>
    <td valign="top" width="33%">Conventional copy</td>
    <td valign="top" width="33%">char</td>
    <td valign="top" width="33%">8.07</td>
  </tr>
  <tr>
    <td valign="top" width="33%">&quot;Optimised&quot; copy</td>
    <td valign="top" width="33%">int</td>
    <td valign="top" width="33%">2.52</td>
  </tr>
  <tr>
    <td valign="top" width="33%">Conventional copy</td>
    <td valign="top" width="33%">int</td>
    <td valign="top" width="33%">8.02</td>
  </tr>
 </table>
 <p>&nbsp;</p>
 <h4>Pair of References</h4>
 <p>The optimised copy example shows how type traits may be used to perform
 optimisation decisions at compile-time. Another important usage of type traits
 is to allow code to compile that otherwise would not do so unless excessive
 partial specialization is used. This is possible by delegating partial
 specialization to the type traits classes. Our example for this form of usage is
 a pair that can hold references [6].</p>
 <p>First, let us examine the definition of &quot;std::pair&quot;, omitting the
 comparision operators, default constructor, and template copy constructor for
 simplicity:</p>
 <pre>template &lt;typename T1, typename T2&gt; 
 struct pair 
 {
  typedef T1 first_type;
  typedef T2 second_type;
  T1 first;
  T2 second;
  pair(const T1 &amp; nfirst, const T2 &amp; nsecond)
  :first(nfirst), second(nsecond) { }
 };</pre>
 <p>Now, this &quot;pair&quot; cannot hold references as it currently stands,
 because the constructor would require taking a reference to a reference, which
 is currently illegal [7]. Let us consider what the constructor's parameters
 would have to be in order to allow &quot;pair&quot; to hold non-reference types,
 references, and constant references:</p>
 <table border="1" cellpadding="7" cellspacing="1" width="638">
  <tr>
    <td valign="top" width="50%">Type of &quot;T1&quot;</td>
    <td valign="top" width="50%">Type of parameter to initializing constructor</td>
  </tr>
  <tr>
    <td valign="top" width="50%">
      <pre>T</pre>
    </td>
    <td valign="top" width="50%">
      <pre>const T &amp;</pre>
    </td>
  </tr>
  <tr>
    <td valign="top" width="50%">
      <pre>T &amp;</pre>
    </td>
    <td valign="top" width="50%">
      <pre>T &amp;</pre>
    </td>
  </tr>
  <tr>
    <td valign="top" width="50%">
      <pre>const T &amp;</pre>
    </td>
    <td valign="top" width="50%">
      <pre>const T &amp;</pre>
    </td>
  </tr>
 </table>
 <p>A little familiarity with the type traits classes allows us to construct a
 single mapping that allows us to determine the type of parameter from the type
 of the contained class. The type traits classes provide a transformation &quot;add_reference&quot;,
 which adds a reference to its type, unless it is already a reference.</p>
 <table border="1" cellpadding="7" cellspacing="1" width="580">
  <tr>
    <td valign="top" width="21%">Type of &quot;T1&quot;</td>
    <td valign="top" width="27%">Type of &quot;const T1&quot;</td>
    <td valign="top" width="53%">Type of &quot;add_reference&lt;const
      T1&gt;::type&quot;</td>
  </tr>
  <tr>
    <td valign="top" width="21%">
      <pre>T</pre>
    </td>
    <td valign="top" width="27%">
      <pre>const T</pre>
    </td>
    <td valign="top" width="53%">
      <pre>const T &amp;</pre>
    </td>
  </tr>
  <tr>
    <td valign="top" width="21%">
      <pre>T &amp;</pre>
    </td>
    <td valign="top" width="27%">
      <pre>T &amp; [8]</pre>
    </td>
    <td valign="top" width="53%">
      <pre>T &amp;</pre>
    </td>
  </tr>
  <tr>
    <td valign="top" width="21%">
      <pre>const T &amp;</pre>
    </td>
    <td valign="top" width="27%">
      <pre>const T &amp;</pre>
    </td>
    <td valign="top" width="53%">
      <pre>const T &amp;</pre>
    </td>
  </tr>
 </table>
 <p>This allows us to build a primary template definition for &quot;pair&quot;
 that can contain non-reference types, reference types, and constant reference
 types:</p>
 <pre>template &lt;typename T1, typename T2&gt; 
 struct pair 
 {
  typedef T1 first_type;
  typedef T2 second_type;
  T1 first;
  T2 second;
  pair(boost::add_reference&lt;const T1&gt;::type nfirst,
       boost::add_reference&lt;const T2&gt;::type nsecond)
  :first(nfirst), second(nsecond) { }
 };</pre>
 <p>Add back in the standard comparision operators, default constructor, and
 template copy constructor (which are all the same), and you have a std::pair
 that can hold reference types!</p>
 <p>This same extension <i>could</i> have been done using partial template
 specialization of &quot;pair&quot;, but to specialize &quot;pair&quot; in this
 way would require three partial specializations, plus the primary template. Type
 traits allows us to define a single primary template that adjusts itself
 auto-magically to any of these partial specializations, instead of a brute-force
 partial specialization approach. Using type traits in this fashion allows
 programmers to delegate partial specialization to the type traits classes,
 resulting in code that is easier to maintain and easier to understand.</p>
 <h4>Conclusion</h4>
 <p>We hope that in this article we have been able to give you some idea of what
 type-traits are all about. A more complete listing of the available classes are
 in the boost documentation, along with further examples using type traits.
 Templates have enabled C++ uses to take the advantage of the code reuse that
 generic programming brings; hopefully this article has shown that generic
 programming does not have to sink to the lowest common denominator, and that
 templates can be optimal as well as generic.</p>
 <h4>Acknowledgements</h4>
 <p>The authors would like to thank Beman Dawes and Howard Hinnant for their
 helpful comments when preparing this article.</p>
 <h4>References</h4>
 <ol>
  <li>Nathan C. Myers, C++ Report, June 1995.</li>
  <li>The type traits library is based upon contributions by Steve Cleary, Beman
    Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org.</li>
  <li>A scalar type is an arithmetic type (i.e. a built-in integer or floating
    point type), an enumeration type, a pointer, a pointer to member, or a
    const- or volatile-qualified version of one of these types.</li>
  <li>This quote is from Donald Knuth, ACM Computing Surveys, December 1974, pg
    268.</li>
  <li>The test code is available as part of the boost utility library (see
    algo_opt_examples.cpp), the code was compiled with gcc 2.95 with all
    optimisations turned on, tests were conducted on a 400MHz Pentium II machine
    running Microsoft Windows 98.</li>
  <li>John Maddock and Howard Hinnant have submitted a &quot;compressed_pair&quot;
    library to Boost, which uses a technique similar to the one described here
    to hold references. Their pair also uses type traits to determine if any of
    the types are empty, and will derive instead of contain to conserve space --
    hence the name &quot;compressed&quot;.</li>
  <li>This is actually an issue with the C++ Core Language Working Group (issue
    #106), submitted by Bjarne Stroustrup. The tentative resolution is to allow
    a &quot;reference to a reference to T&quot; to mean the same thing as a
    &quot;reference to T&quot;, but only in template instantiation, in a method
    similar to multiple cv-qualifiers.</li>
  <li>For those of you who are wondering why this shouldn't be const-qualified,
    remember that references are always implicitly constant (for example, you
    can't re-assign a reference). Remember also that &quot;const T &amp;&quot;
    is something completely different. For this reason, cv-qualifiers on
    template type arguments that are references are ignored.</li>
 </ol>
 <h2>Listing 1</h2>
 <pre>namespace detail{
 template &lt;bool b&gt;
 struct copier
 {
   template&lt;typename I1, typename I2&gt;
   static I2 do_copy(I1 first, 
                     I1 last, I2 out);
 };
 template &lt;bool b&gt;
 template&lt;typename I1, typename I2&gt;
 I2 copier&lt;b&gt;::do_copy(I1 first, 
                      I1 last, 
                      I2 out)
 {
   while(first != last)
   {
      *out = *first;
      ++out;
      ++first;
   }
   return out;
 }
 template &lt;&gt;
 struct copier&lt;true&gt;
 {
   template&lt;typename I1, typename I2&gt;
   static I2* do_copy(I1* first, I1* last, I2* out)
   {
      memcpy(out, first, (last-first)*sizeof(I2));
      return out+(last-first);
   }
 };
 }
 template&lt;typename I1, typename I2&gt;
 inline I2 copy(I1 first, I1 last, I2 out)
 {
   typedef typename 
    boost::remove_cv&lt;
     typename std::iterator_traits&lt;I1&gt;
      ::value_type&gt;::type v1_t;
   typedef typename 
    boost::remove_cv&lt;
     typename std::iterator_traits&lt;I2&gt;
      ::value_type&gt;::type v2_t;
   enum{ can_opt = 
      boost::is_same&lt;v1_t, v2_t&gt;::value
      &amp;&amp; boost::is_pointer&lt;I1&gt;::value
      &amp;&amp; boost::is_pointer&lt;I2&gt;::value
      &amp;&amp; boost::
      has_trivial_assign&lt;v1_t&gt;::value 
   };
   return detail::copier&lt;can_opt&gt;::
      do_copy(first, last, out);
 }</pre>
 <hr>
 <p><EFBFBD> Copyright John Maddock and Steve Cleary, 2000</p>
 </body>
 </html>
--- 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
@ -27,10 +27,16 @@ never occur, and that parameters are passed in the most efficient
 manner possible (see <a href="#examples">examples</a>). In each
 case if your existing practice is to use the type defined on the
 left, then replace it with the call_traits defined type on the
-right. Note that for compilers that do not support partial
+right. </p>
-specialization, no benefit will occur from using call_traits: the
+
-call_traits defined types will always be the same as the existing
+<p>Note that for compilers that do not support either partial
-practice in this case.</p>
+specialization or member templates, no benefit will occur from
 using call_traits: the call_traits defined types will always be
 the same as the existing practice in this case. In addition if
 only member templates and not partial template specialisation is
 support by the compiler (for example Visual C++ 6) then
 call_traits can not be used with array types (although it can be
 used to solve the reference to reference problem).</p>
 <table border="0" cellpadding="7" cellspacing="1" width="797">
    <tr>
@ -73,7 +79,8 @@ practice in this case.</p>
        </td>
    </tr>
    <tr>
-        <td valign="top" width="17%"><p align="center">const T&amp;<br>
+        <td valign="top" width="17%"><p align="center">const
        T&amp;<br>
        (return value)</p>
        </td>
        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::const_reference</code></p>
@ -85,7 +92,8 @@ practice in this case.</p>
        </td>
    </tr>
    <tr>
-        <td valign="top" width="17%"><p align="center">const T&amp;<br>
+        <td valign="top" width="17%"><p align="center">const
        T&amp;<br>
        (function parameter)</p>
        </td>
        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::param_type</code></p>
@ -326,8 +334,8 @@ possible:</p>
 <p>The following table shows the effect that call_traits has on
 various types, the table assumes that the compiler supports
 partial specialization: if it doesn't then all types behave in
-the same way as the entry for &quot;myclass&quot;, and call_traits
+the same way as the entry for &quot;myclass&quot;, and
-can not be used with reference or array types.</p>
+call_traits can not be used with reference or array types.</p>
 <table border="0" cellpadding="7" cellspacing="1" width="766">
    <tr>
@ -382,7 +390,8 @@ can not be used with reference or array types.</p>
        </td>
        <td valign="top" width="17%"><p align="center">int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
        int&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">int const</p>
        </td>
@ -414,7 +423,8 @@ can not be used with reference or array types.</p>
        </td>
        <td valign="top" width="17%"><p align="center">int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
        int&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">int&amp;</p>
        </td>
@ -426,13 +436,17 @@ can not be used with reference or array types.</p>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">const int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
        int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
        int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
        int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
        int&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">All
        constant-references.</p>
@ -480,8 +494,8 @@ can not be used with reference or array types.</p>
 <p>The following class is a trivial class that stores some type T
 by value (see the <a href="call_traits_test.cpp">call_traits_test.cpp</a>
-file), the aim is to illustrate how each of the available call_traits
+file), the aim is to illustrate how each of the available
-typedefs may be used:</p>
+call_traits typedefs may be used:</p>
 <pre>template &lt;class T&gt;
 struct contained
@ -517,14 +531,14 @@ problem):</h4>
 <pre>template &lt;class Operation&gt; 
 class binder1st : 
-   public unary_function&lt;Operation::second_argument_type, Operation::result_type&gt; 
+   public unary_function&lt;typename Operation::second_argument_type, typename Operation::result_type&gt; 
 { 
 protected: 
   Operation op; 
-   Operation::first_argument_type value; 
+   typename Operation::first_argument_type value; 
 public: 
-   binder1st(const Operation&amp; x, const Operation::first_argument_type&amp; y); 
+   binder1st(const Operation&amp; x, const typename Operation::first_argument_type&amp; y); 
-   Operation::result_type operator()(const Operation::second_argument_type&amp; x) const; 
+   typename Operation::result_type operator()(const typename Operation::second_argument_type&amp; x) const; 
 }; </pre>
 <p>Now consider what happens in the relatively common case that
@ -535,7 +549,7 @@ reference to a reference as an argument, and that is not
 currently legal. The solution here is to modify <code>operator()</code>
 to use call_traits:</p>
-<pre>Operation::result_type operator()(call_traits&lt;Operation::second_argument_type&gt;::param_type x) const;</pre>
+<pre>typename Operation::result_type operator()(typename call_traits&lt;typename Operation::second_argument_type&gt;::param_type x) const;</pre>
 <p>Now in the case that <code>Operation::second_argument_type</code>
 is a reference type, the argument is passed as a reference, and
@ -569,14 +583,17 @@ std::pair&lt;
 degraded to pointers if the deduced types are arrays, similar
 situations occur in the standard binders and adapters: in
 principle in any function that &quot;wraps&quot; a temporary
-whose type is deduced.</p>
+whose type is deduced. Note that the function arguments to
 make_pair are not expressed in terms of call_traits: doing so
 would prevent template argument deduction from functioning.</p>
 <h4><a name="ex4"></a>Example 4 (optimising fill):</h4>
 <p>The call_traits template will &quot;optimize&quot; the passing
 of a small built-in type as a function parameter, this mainly has
 an effect when the parameter is used within a loop body. In the
-following example (see <a href="algo_opt_examples.cpp">algo_opt_examples.cpp</a>),
+following example (see <a
 href="../type_traits/examples/fill_example.cpp">fill_example.cpp</a>),
 a version of std::fill is optimized in two ways: if the type
 passed is a single byte built-in type then std::memset is used to
 effect the fill, otherwise a conventional C++ implemention is
@ -589,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)
      {
@ -632,6 +649,14 @@ Exactly how much mileage you will get from this depends upon your
 compiler - we could really use some accurate benchmarking
 software as part of boost for cases like this.</p>
 <p>Note that the function arguments to fill are not expressed in
 terms of call_traits: doing so would prevent template argument
 deduction from functioning. Instead fill acts as a &quot;thin
 wrapper&quot; that is there to perform template argument
 deduction, the compiler will optimise away the call to fill all
 together, replacing it with the call to filler&lt;&gt;::do_fill,
 which does use call_traits.</p>
 <h3>Rationale</h3>
 <p>The following notes are intended to briefly describe the
@ -650,10 +675,10 @@ be any worse than existing practice.</p>
 <p>Pointers follow the same rational as small built-in types.</p>
 <p>For reference types the rational follows <a href="#refs">Example
-2</a> - references to references are not allowed, so the call_traits
+2</a> - references to references are not allowed, so the
-members must be defined such that these problems do not occur.
+call_traits members must be defined such that these problems do
-There is a proposal to modify the language such that &quot;a
+not occur. There is a proposal to modify the language such that
-reference to a reference is a reference&quot; (issue #106,
+&quot;a reference to a reference is a reference&quot; (issue #106,
 submitted by Bjarne Stroustrup), call_traits&lt;T&gt;::value_type
 and call_traits&lt;T&gt;::param_type both provide the same effect
 as that proposal, without the need for a language change (in
@ -671,11 +696,11 @@ struct A
   void foo(T t);
 };</pre>
-<p><font face="Times New Roman">In this case if we instantiate A&lt;int[2]&gt;
+<p><font face="Times New Roman">In this case if we instantiate
-then the declared type of the parameter passed to member function
+A&lt;int[2]&gt; then the declared type of the parameter passed to
-foo is int[2], but it's actual type is const int*, if we try to
+member function foo is int[2], but it's actual type is const int*,
-use the type T within the function body, then there is a strong
+if we try to use the type T within the function body, then there
-likelyhood that our code will not compile:</font></p>
+is a strong likelyhood that our code will not compile:</font></p>
 <pre>template &lt;class T&gt;
 void A&lt;T&gt;::foo(T t)
@ -690,13 +715,13 @@ declared type:</p>
 <pre>template &lt;class T&gt;
 struct A
 {
-   void foo(call_traits&lt;T&gt;::value_type t);
+   void foo(typename call_traits&lt;T&gt;::value_type t);
 };
 template &lt;class T&gt;
-void A&lt;T&gt;::foo(call_traits&lt;T&gt;::value_type t)
+void A&lt;T&gt;::foo(typename call_traits&lt;T&gt;::value_type t)
 {
-   call_traits&lt;T&gt;::value_type dup(t); // OK even if T is an array type.
+   typename call_traits&lt;T&gt;::value_type dup(t); // OK even if T is an array type.
 }</pre>
 <p>For value_type (return by value), again only a pointer may be
@ -713,26 +738,18 @@ specialisation).</p>
 <hr>
-<p>Revised 18 June 2000</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.egroups.com/list/boost">www.egroups.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,20 +1,33 @@
- // 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:
 //    Changed some names to prevent conflicts with some new type_traits additions.
 // 03 Oct 2000:
 //    Enabled extra tests for VC6.
 #include <cassert>
 #include <iostream>
 #include <iomanip>
 #include <algorithm>
 #include <typeinfo>
 #include <boost/call_traits.hpp>
-#include "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&) {}
 //
 // struct contained models a type that contains a type (for example std::pair)
 // arrays are contained by value, and have to be treated as a special case:
@ -42,8 +55,9 @@ struct contained
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
   // pass value:
-   void call(param_type p){}
+   void call(param_type){}
-
+private:
   contained& operator=(const contained&);
 };
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@ -67,12 +81,14 @@ struct contained<T[N]>
   // return by_ref:
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
-   void call(param_type p){}
+   void call(param_type){}
 private:
   contained& operator=(const contained&);
 };
 #endif
 template <class T>
-contained<typename boost::call_traits<T>::value_type> wrap(const T& t)
+contained<typename boost::call_traits<T>::value_type> test_wrap_type(const T& t)
 {
   typedef typename boost::call_traits<T>::value_type ct;
   return contained<ct>(t);
@ -96,37 +112,38 @@ std::pair<
 using namespace std;
 //
-// struct checker:
+// struct call_traits_checker:
 // verifies behaviour of contained example:
 //
 template <class T>
-struct checker
+struct call_traits_checker
 {
   typedef typename boost::call_traits<T>::param_type param_type;
   void operator()(param_type);
 };
 template <class T>
-void checker<T>::operator()(param_type p)
+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() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::value() is:      " << typeid(&contained<T>::value).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::get() is:        " << typeid(&contained<T>::get).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::const_get() is:  " << typeid(&contained<T>::const_get).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::call() is:       " << typeid(&contained<T>::call).name() << endl;
   cout << endl;
 #endif
 }
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T, std::size_t N>
-struct checker<T[N]>
+struct call_traits_checker<T[N]>
 {
   typedef typename boost::call_traits<T[N]>::param_type param_type;
   void operator()(param_type t)
@ -135,11 +152,11 @@ struct 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;
@ -153,11 +170,11 @@ struct checker<T[N]>
 //
 // check_wrap:
-template <class T, class U>
+template <class W, class U>
-void check_wrap(const contained<T>& w, const U& u)
+void check_wrap(const W& w, const U& u)
 {
-   cout << "checking contained<" << typeid(T).name() << ">..." << endl;
+   cout << "checking " << typeid(W).name() << "..." << endl;
-   assert(w.value() == u);
+   BOOST_CHECK(w.value() == u);
 }
 //
@ -168,47 +185,51 @@ 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;
 }
-struct UDT
+struct comparible_UDT
 {
   int i_;
-   UDT() : i_(2){}
+   comparible_UDT() : i_(2){}
-   bool operator == (const UDT& v){ return v.i_ == i_; }
+   comparible_UDT(const comparible_UDT& other) : i_(other.i_){}
   comparible_UDT& operator=(const comparible_UDT& other)
   { 
      i_ = other.i_;
      return *this;
   }
   bool operator == (const comparible_UDT& v){ return v.i_ == i_; }
 };
 int main()
 {
-   checker<UDT> c1;
+   call_traits_checker<comparible_UDT> c1;
-   UDT u;
+   comparible_UDT u;
   c1(u);
-   checker<int> c2;
+   call_traits_checker<int> c2;
   int i = 2;
   c2(i);
   int* pi = &i;
   checker<int*> c3;
   c3(pi);
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   checker<int&> c4;
   c4(i);
   checker<const int&> c5;
   c5(i);
   int a[2] = {1,2};
-   checker<int[2]> c6;
+#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) && !defined(__ICL)
   call_traits_checker<int*> c3;
   c3(pi);
   call_traits_checker<int&> c4;
   c4(i);
   call_traits_checker<const int&> c5;
   c5(i);
 #if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__MWERKS__) && !defined(__SUNPRO_CC)
   call_traits_checker<int[2]> c6;
   c6(a);
 #endif
 #endif
-   check_wrap(wrap(2), 2);
+   check_wrap(test_wrap_type(2), 2);
-   const char ca[4] = "abc";
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
-   // compiler can't deduce this for some reason:
+   check_wrap(test_wrap_type(a), a);
   //check_wrap(wrap(ca), ca);
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   check_wrap(wrap(a), a);
   check_make_pair(test::make_pair(a, a), a, a);
 #endif
@ -217,59 +238,67 @@ int main()
   typedef int& r_type;
   typedef const r_type cr_type;
-   type_test(UDT, boost::call_traits<UDT>::value_type)
+   BOOST_CHECK_TYPE(comparible_UDT, boost::call_traits<comparible_UDT>::value_type);
-   type_test(UDT&, boost::call_traits<UDT>::reference)
+   BOOST_CHECK_TYPE(comparible_UDT&, boost::call_traits<comparible_UDT>::reference);
-   type_test(const UDT&, boost::call_traits<UDT>::const_reference)
+   BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference);
-   type_test(const UDT&, boost::call_traits<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);
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#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))
+#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);
-   type_test(const int*, boost::call_traits<int[3]>::value_type)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   type_test(int(&)[3], boost::call_traits<int[3]>::reference)
+   BOOST_CHECK_TYPE(const int*, boost::call_traits<int[3]>::value_type);
-   type_test(const int(&)[3], boost::call_traits<int[3]>::const_reference)
+   BOOST_CHECK_TYPE(int(&)[3], boost::call_traits<int[3]>::reference);
-   type_test(const int*const, boost::call_traits<int[3]>::param_type)
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<int[3]>::const_reference);
-   type_test(const int*, boost::call_traits<const int[3]>::value_type)
+   BOOST_CHECK_TYPE(const int*const, boost::call_traits<int[3]>::param_type);
-   type_test(const int(&)[3], boost::call_traits<const int[3]>::reference)
+   BOOST_CHECK_TYPE(const int*, boost::call_traits<const int[3]>::value_type);
-   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]>::reference);
-   type_test(const int*const, boost::call_traits<const int[3]>::param_type)
+   BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::const_reference);
   BOOST_CHECK_TYPE(const int*const, boost::call_traits<const int[3]>::param_type);
   // test with abstract base class:
   BOOST_CHECK_TYPE(test_abc1, boost::call_traits<test_abc1>::value_type);
   BOOST_CHECK_TYPE(test_abc1&, boost::call_traits<test_abc1>::reference);
   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::const_reference);
   BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::param_type);
 #else
-   std::cout << "You're compiler does not support partial template instantiation, skipping 20 tests (20 errors)" << std::endl;
+   std::cout << "You're compiler does not support partial template specialiation, skipping 8 tests (8 errors)" << std::endl;
   failures += 20;
   test_count += 20;
 #endif
 #else
   std::cout << "You're compiler does not support partial template specialiation, skipping 20 tests (20 errors)" << std::endl;
 #endif
   // test with an incomplete type:
   BOOST_CHECK_TYPE(incomplete_type, boost::call_traits<incomplete_type>::value_type);
   BOOST_CHECK_TYPE(incomplete_type&, boost::call_traits<incomplete_type>::reference);
   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
   BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);
-   std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
+   return 0;
   std::cin.get();
   return failures;
 }
 //
 // 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
@ -304,6 +333,19 @@ void call_traits_test<T, isarray>::assert_construct(typename call_traits_test<T,
   param_type p2(v);
   param_type p3(r);
   param_type p4(p);
   unused_variable(v2);
   unused_variable(v3);
   unused_variable(v4);
   unused_variable(r2);
   unused_variable(r3);
   unused_variable(cr2);
   unused_variable(cr3);
   unused_variable(cr4);
   unused_variable(cr5);
   unused_variable(p2);
   unused_variable(p3);
   unused_variable(p4);
 }
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <typename T>
@ -318,7 +360,7 @@ struct call_traits_test<T, true>
 };
 template <typename T>
-void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_type val)
+void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>::param_type val)
 {
   //
   // this is to check that the call_traits assertions are valid:
@ -340,6 +382,19 @@ void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_ty
   param_type p2(v);
   param_type p3(r);
   param_type p4(p);
   unused_variable(v2);
   unused_variable(v3);
   unused_variable(v4);
   unused_variable(v5);
 #ifndef __BORLANDC__
   unused_variable(r2);
   unused_variable(cr2);
 #endif
   unused_variable(cr3);
   unused_variable(p2);
   unused_variable(p3);
   unused_variable(p4);
 }
 #endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 //
@ -347,9 +402,11 @@ void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_ty
 template struct call_traits_test<int>;
 template struct call_traits_test<const int>;
 template struct call_traits_test<int*>;
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 template struct call_traits_test<int&>;
 template struct call_traits_test<const int&>;
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
 template struct call_traits_test<int[2], true>;
 #endif
 #endif
--- a/cast.htm
+++ b/cast.htm
@ -1,148 +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>Header boost/cast.hpp Documentation</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
 <a href="../../boost/cast.hpp">boost/cast.hpp</a></h1>
 <h2><a name="Cast Functions">Cast Functions</a></h2>
 <p>The <code>header <a href="../../boost/cast.hpp">boost/cast.hpp</a></code>
 provides <a href="#Polymorphic_cast"><b>polymorphic_cast</b></a>, <a href="#Polymorphic_cast"><b>polymorphic_downcast</b></a>,
 and <a href="#numeric_cast"><b>numeric_cast</b></a> template functions designed
 to complement the C++ Standard's built-in casts.</p>
 <p>The program&nbsp;<a href="cast_test.cpp">cast_test.cpp</a> can be used to
 verify these function templates work as expected.</p>
 <p><b>polymorphic_cast</b> was suggested by Bjarne Stroustrup in &quot;The C++
 Programming Language&quot;.<br>
 <b>polymorphic_downcast</b> was contributed by <a href="../../people/dave_abrahams.htm">Dave
 Abrahams</a>.<b><br>
 numeric_cast</b> was contributed by <a href="../../people/kevlin_henney.htm">Kevlin
 Henney</a>.</p>
 <h3>Namespace synopsis</h3>
 <blockquote>
  <pre>namespace boost {
    namespace cast {
        // all synopsis below included here
    }
  using ::boost::cast::polymorphic_cast;
  using ::boost::cast::polymorphic_downcast;
  using ::boost::cast::bad_numeric_cast;
  using ::boost::cast::numeric_cast;
 }</pre>
 </blockquote>
 <h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
 <p>Pointers to polymorphic objects (objects of classes which define at least one
 virtual function) are sometimes downcast or crosscast.&nbsp; Downcasting means
 casting from a base class to a derived class.&nbsp; Crosscasting means casting
 across an inheritance hierarchy diagram, such as from one base to the other in a
 <b>Y</b> diagram hierarchy.</p>
 <p>Such casts can be done with old-style casts, but this approach is never to be
 recommended.&nbsp; Old-style casts are sorely lacking in type safety, suffer
 poor readability, and are difficult to locate with search tools.</p>
 <p>The C++ built-in <b>static_cast</b> can be used for efficiently downcasting
 pointers to polymorphic objects, but provides no error detection for the case
 where the pointer being cast actually points to the wrong derived class. The <b>polymorphic_downcast</b>
 template retains the efficiency of <b>static_cast</b> for non-debug
 compilations, but for debug compilations adds safety via an assert() that a <b>dynamic_cast</b>
 succeeds.&nbsp;<b>&nbsp;</b></p>
 <p>The C++ built-in <b>dynamic_cast</b> can be used for downcasts and crosscasts
 of pointers to polymorphic objects, but error notification in the form of a
 returned value of 0 is inconvenient to test, or worse yet, easy to forget to
 test.&nbsp; The <b>polymorphic_cast</b> template performs a <b>dynamic_cast</b>,
 and throws an exception if the <b>dynamic_cast</b> returns 0.</p>
 <p>A <b>polymorphic_downcast</b> is preferred when debug-mode tests will cover
 100% of the object types possibly cast and when non-debug-mode efficiency is an
 issue. If these two conditions are not present, <b>polymorphic_cast</b> is
 preferred.&nbsp; It must also be used for crosscasts.&nbsp; It does an assert(
 dynamic_cast&lt;Derived&gt;(x) == x ) where x is the base pointer, ensuring that
 not only is a non-zero pointer returned, but also that it correct in the
 presence of multiple inheritance. .<b> Warning:</b>: Because <b>polymorphic_downcast</b>
 uses assert(), it violates the One Definition Rule if NDEBUG is inconsistently
 defined across translation units.</p>
 <p>The C++ built-in <b>dynamic_cast</b> must be used to cast references rather
 than pointers.&nbsp; It is also the only cast that can be used to check whether
 a given interface is supported; in that case a return of 0 isn't an error
 condition.</p>
 <h3>polymorphic_cast and polymorphic_downcast synopsis</h3>
 <blockquote>
  <pre>template &lt;class Derived, class Base&gt;
 inline Derived polymorphic_cast(Base* x);
 // Throws: std::bad_cast if ( dynamic_cast&lt;Derived&gt;(x) == 0 )
 // Returns: dynamic_cast&lt;Derived&gt;(x)
 template &lt;class Derived, class Base&gt;
 inline Derived polymorphic_downcast(Base* x);
 // Effects: assert( dynamic_cast&lt;Derived&gt;(x) == x );
 // Returns: static_cast&lt;Derived&gt;(x)</pre>
 </blockquote>
 <h3>polymorphic_downcast example</h3>
 <blockquote>
  <pre>#include &lt;boost/cast.hpp&gt;
 ...
 class Fruit { public: virtual ~Fruit(){}; ... };
 class Banana : public Fruit { ... };
 ...
 void f( Fruit * fruit ) {
 // ... logic which leads us to believe it is a Banana
  Banana * banana = boost::polymorphic_downcast&lt;Banana*&gt;(fruit);
  ...</pre>
 </blockquote>
 <h3><a name="numeric_cast">numeric_cast</a></h3>
 <p>A <b>static_cast</b>, <b>implicit_cast</b> or implicit conversion will not
 detect failure to preserve range for numeric casts. The <b>numeric_cast</b>
 template function are similar to <b>static_cast</b> and certain (dubious)
 implicit conversions in this respect, except that they detect loss of numeric
 range. An exception is thrown when a runtime value preservation check fails.</p>
 <p>The requirements on the argument and result types are:</p>
 <blockquote>
  <ul>
    <li>Both argument and result types are CopyConstructible [20.1.3].</li>
    <li>Both argument and result types are Numeric, defined by <code>std::numeric_limits&lt;&gt;::is_specialized</code>
      being true.</li>
    <li>The argument can be converted to the result type using <b>static_cast</b>.</li>
  </ul>
 </blockquote>
 <h3>numeric_cast synopsis</h3>
 <blockquote>
  <pre>class bad_numeric_cast : public std::bad_cast {...};
 template&lt;typename Target, typename Source&gt;
  inline Target numeric_cast(Source arg);
    // Throws:  bad_numeric_cast unless, in converting arg from Source to Target,
    //          there is no loss of negative range, and no underflow, and no
    //          overflow, as determined by std::numeric_limits
    // Returns: static_cast&lt;Target&gt;(arg)</pre>
 </blockquote>
 <h3>numeric_cast example</h3>
 <blockquote>
  <pre>#include &lt;boost/cast.hpp&gt;
 using namespace boost::cast;
 void ariane(double vx)
 {
    ...
    unsigned short dx = numeric_cast&lt;unsigned short&gt;(vx);
    ...
 }</pre>
 </blockquote>
 <h3>numeric_cast rationale</h3>
 <p>The form of the throws condition is specified so that != is not a required
 operation.</p>
 <hr>
 <p>Revised&nbsp; <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
 -->28 June, 2000<!--webbot bot="Timestamp" endspan i-checksum="19846"
 --></p>
 <p><EFBFBD> Copyright boost.org 1999. 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/cast_test.cpp
+++ b/cast_test.cpp
@ -1,149 +0,0 @@
 //  boost utility cast test program  -----------------------------------------//
 //  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
 //  and distribute this software is granted provided this copyright
 //  notice appears in all copies. This software is provided "as is" without
 //  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
 //  See http://www.boost.org for most recent version including documentation.
 //  Revision History
 //   28 Jun 00  implicit_cast removed (Beman Dawes)
 //   30 Aug 99  value_cast replaced by numeric_cast
 //    3 Aug 99  Initial Version
 #include <iostream>
 #include <climits>
 #include <limits>
 #include <boost/cast.hpp>
 #  if SCHAR_MAX == LONG_MAX
 #      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
 #  endif 
 using namespace boost;
 using std::cout;
 namespace
 {
    struct Base
    { 
        virtual char kind() { return 'B'; }
    };
    struct Base2
    { 
        virtual char kind2() { return '2'; }
    };
    struct Derived : public Base, Base2
    {
        virtual char kind() { return 'D'; }
    }; 
 }   
 int main( int argc, char * argv[] )
 {
    cout << "Usage: test_casts [n], where n omitted or is:\n"
            "  1 = execute #1 assert failure (#ifndef NDEBUG)\n"
            "  2 = execute #2 assert failure (#ifndef NDEBUG)\n"
            "Example: test_casts 2\n\n";
 #   ifdef NDEBUG
        cout << "NDEBUG is defined\n";
 #   else
        cout << "NDEBUG is not defined\n";
 #   endif
    cout << "\nBeginning tests...\n";        
 //  test polymorphic_cast  ---------------------------------------------------//
    //  tests which should succeed
    Base *    base = new Derived;
    Base2 *   base2 = 0;
    Derived * derived = 0;
    derived = polymorphic_downcast<Derived*>( base );  // downcast
    assert( derived->kind() == 'D' );
    derived = 0;
    derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
    assert( derived->kind() == 'D' );
    base2 = polymorphic_cast<Base2*>( base ); // crosscast
    assert( base2->kind2() == '2' );
     //  tests which should result in errors being detected
    int err_count = 0;
    base = new Base;
    if ( argc > 1 && *argv[1] == '1' )
        { derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
    bool caught_exception = false;
    try { derived = polymorphic_cast<Derived*>( base ); }
    catch (std::bad_cast)
        { cout<<"caught bad_cast\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    //  the following is just so generated code can be inspected
    if ( derived->kind() == 'B' ) ++err_count;
 //  test implicit_cast and numeric_cast  -------------------------------------//
    //  tests which should succeed
    long small_value = 1;
    long small_negative_value = -1;
    long large_value = std::numeric_limits<long>::max();
    long large_negative_value = std::numeric_limits<long>::min();
    signed char c = 0;
    c = large_value;  // see if compiler generates warning
    c = numeric_cast<signed char>( small_value );
    assert( c == 1 );
    c = 0;
    c = numeric_cast<signed char>( small_value );
    assert( c == 1 );
    c = 0;
    c = numeric_cast<signed char>( small_negative_value );
    assert( c == -1 );
    //  tests which should result in errors being detected
    caught_exception = false;
    try { c = numeric_cast<signed char>( large_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    caught_exception = false;
    try { c = numeric_cast<signed char>( large_negative_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    unsigned long ul;
    caught_exception = false;
    try { ul = numeric_cast<unsigned long>( large_negative_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    caught_exception = false;
    try { ul = numeric_cast<unsigned long>( small_negative_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    caught_exception = false;
    try { numeric_cast<int>( std::numeric_limits<double>::max() ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    cout << err_count << " errors detected\nTest "
         << (err_count==0 ? "passed\n" : "failed\n");
    return err_count;
 }   // main
--- 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
@ -0,0 +1,28 @@
 //  Boost checked_delete test program  ---------------------------------------//
 //  Copyright Beman Dawes 2001.  Distributed under the Boost
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //  See http://www.boost.org/libs/utility for documentation.
 //  Revision History
 //  21 May 01  Initial version (Beman Dawes)
 #include <boost/checked_delete.hpp>  // for checked_delete
 //  This program demonstrates compiler errors when trying to delete an
 //  incomplete type.
 namespace
 {
    class Incomplete;
 }
 int main()
 {
    Incomplete * p = 0;
    boost::checked_delete(p);          // should cause compile time error
    boost::checked_array_delete(p);    // should cause compile time error
    return 0;
 }   // main
--- a/compressed_pair.htm
+++ b/compressed_pair.htm
@ -1,29 +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 <boost/compressed_pair.hpp></title>
+   <body bgcolor="#ffffff" text="#000000" link="#0000ff" vlink="#800080">
-</head>
+      <h2><img src="../../boost.png" width="276" height="86">Header &lt;<a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a>&gt;</h2>
-
+      <p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are defined inside 
-<body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
+         namespace boost.</p>
-vlink="#800080">
+      <p>The class compressed pair is very similar to std::pair, but if either of the 
-
+         template arguments are empty classes, then the "empty base-class optimisation" 
-<h2><img src="../../c++boost.gif" width="276" height="86">Header
+         is applied to compress the size of the pair.</p>
-&lt;<a href="../../boost/detail/call_traits.hpp">boost/compressed_pair.hpp</a>&gt;</h2>
+      <pre>template &lt;class T1, class T2&gt;
 <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 member optimisation&quot; is applied to compress the
 size of the pair.</p>
 <pre>template &lt;class T1, class T2&gt;
 class compressed_pair
 {
 public:
@ -41,6 +31,8 @@ public:
 	explicit compressed_pair(first_param_type x);
 	explicit compressed_pair(second_param_type y);
 	compressed_pair&amp; operator=(const compressed_pair&amp;);
 	first_reference       first();
 	first_const_reference first() const;
@ -49,44 +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 an enumerator type, unless there is
 compiler support for boost::is_enum, or if boost::is_enum is
 specialised for the enumerator type.</p>
 <p>Finally, compressed_pair requires compiler support for partial
 specialisation of class templates - without that support
 compressed_pair behaves just like std::pair.</p>
 <hr>
 <p>Revised 08 March 2000</p>
 <p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
 sell and distribute this document is granted provided this
 copyright notice appears in all copies. This document is provided
 &quot;as is&quot; without express or implied warranty, and with
 no claim as to its suitability for any purpose.</p>
 <p>Based on contributions by Steve Cleary, Beman Dawes, Howard
 Hinnant and John Maddock.</p>
 <p>Maintained by <a href="mailto:John_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.egroups.com/list/boost">www.egroups.com/list/boost</a>.</p>
 <p>&nbsp;</p>
 </body>
 </html>
--- a/compressed_pair_test.cpp
+++ b/compressed_pair_test.cpp
@ -1,125 +1,393 @@
- // 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: 
 //    Enabled tests for VC6.
 #include <iostream>
 #include <typeinfo>
 #include <cassert>
 #include <boost/compressed_pair.hpp>
-#include "type_traits_test.hpp"
+#include <boost/test/test_tools.hpp>
 using namespace boost;
 struct empty_POD_UDT{};
 struct empty_UDT
 {
-  ~empty_UDT(){};
+   ~empty_UDT(){};
   empty_UDT& operator=(const empty_UDT&){ return *this; }
   bool operator==(const empty_UDT&)const
   { return true; }
 };
-namespace boost {
+struct empty_POD_UDT
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 template <> struct is_empty<empty_UDT>
 { static const bool value = true; };
 template <> struct is_empty<empty_POD_UDT>
 { static const bool value = true; };
 template <> struct is_POD<empty_POD_UDT>
 { static const bool value = true; };
 #else
 template <> struct is_empty<empty_UDT>
 { enum{ value = true }; };
 template <> struct is_empty<empty_POD_UDT>
 { enum{ value = true }; };
 template <> struct is_POD<empty_POD_UDT>
 { enum{ value = true }; };
 #endif
 }
 int main()
 {
-   compressed_pair<int, double> cp1(1, 1.3);
+   empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; }
-   assert(cp1.first() == 1);
+   bool operator==(const empty_POD_UDT&)const
-   assert(cp1.second() == 1.3);
+   { return true; }
-   compressed_pair<int, double> cp1b(2, 2.3);
+};
   assert(cp1b.first() == 2);
   assert(cp1b.second() == 2.3);
   swap(cp1, cp1b);
   assert(cp1b.first() == 1);
   assert(cp1b.second() == 1.3);
   assert(cp1.first() == 2);
   assert(cp1.second() == 2.3);
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   compressed_pair<empty_UDT, int> cp2(2);
   assert(cp2.second() == 2);
 #endif
   compressed_pair<int, empty_UDT> cp3(1);
   assert(cp3.first() ==1);
   compressed_pair<empty_UDT, empty_UDT> cp4;
   compressed_pair<empty_UDT, empty_POD_UDT> cp5;
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   int i = 0;
   compressed_pair<int&, int&> cp6(i,i);
   assert(cp6.first() == i);
   assert(cp6.second() == i);
   assert(&cp6.first() == &i);
   assert(&cp6.second() == &i);
   compressed_pair<int, double[2]> cp7;
   cp7.first();
   double* pd = cp7.second();
 #endif
   value_test(true, (sizeof(compressed_pair<empty_UDT, int>) < sizeof(std::pair<empty_UDT, int>)))
   value_test(true, (sizeof(compressed_pair<int, empty_UDT>) < sizeof(std::pair<int, empty_UDT>)))
   value_test(true, (sizeof(compressed_pair<empty_UDT, empty_UDT>) < sizeof(std::pair<empty_UDT, empty_UDT>)))
   value_test(true, (sizeof(compressed_pair<empty_UDT, empty_POD_UDT>) < sizeof(std::pair<empty_UDT, empty_POD_UDT>)))
   value_test(true, (sizeof(compressed_pair<empty_UDT, compressed_pair<empty_POD_UDT, int> >) < sizeof(std::pair<empty_UDT, std::pair<empty_POD_UDT, int> >)))
-   std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
+struct non_empty1
-   std::cin.get();
+{ 
-   return failures;
+   int i;
   non_empty1() : i(1){}
   non_empty1(int v) : i(v){}
   friend bool operator==(const non_empty1& a, const non_empty1& b)
   { return a.i == b.i; }
 };
 struct non_empty2
 { 
   int i;
   non_empty2() : i(3){}
   non_empty2(int v) : i(v){}
   friend bool operator==(const non_empty2& a, const non_empty2& b)
   { return a.i == b.i; }
 };
 #ifdef __GNUC__
 using std::swap;
 #endif
 template <class T1, class T2>
 struct compressed_pair_tester
 {
   // define the types we need:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   // define our test proc:
   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
 };
 template <class T1, class T2>
 void compressed_pair_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
 {
 #ifndef __GNUC__
   // gcc 2.90 can't cope with function scope using
   // declarations, and generates an internal compiler error...
   using std::swap;
 #endif
   // default construct:
   boost::compressed_pair<T1,T2> cp1;
   // first param construct:
   boost::compressed_pair<T1,T2> cp2(p1);
   cp2.second() = p2;
   BOOST_CHECK(cp2.first() == p1);
   BOOST_CHECK(cp2.second() == p2);
   // second param construct:
   boost::compressed_pair<T1,T2> cp3(p2);
   cp3.first() = p1;
   BOOST_CHECK(cp3.second() == p2);
   BOOST_CHECK(cp3.first() == p1);
   // both param construct:
   boost::compressed_pair<T1,T2> cp4(p1, p2);
   BOOST_CHECK(cp4.first() == p1);
   BOOST_CHECK(cp4.second() == p2);
   boost::compressed_pair<T1,T2> cp5(p3, p4);
   BOOST_CHECK(cp5.first() == p3);
   BOOST_CHECK(cp5.second() == p4);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
   BOOST_CHECK(cpr1.first() == p1);
   BOOST_CHECK(cpr1.second() == p2);
   // copy construct:
   boost::compressed_pair<T1,T2> cp6(cp4);
   BOOST_CHECK(cp6.first() == p1);
   BOOST_CHECK(cp6.second() == p2);
   // assignment:
   cp1 = cp4;
   BOOST_CHECK(cp1.first() == p1);
   BOOST_CHECK(cp1.second() == p2);
   cp1 = cp5;
   BOOST_CHECK(cp1.first() == p3);
   BOOST_CHECK(cp1.second() == p4);
   // swap:
   cp4.swap(cp5);
   BOOST_CHECK(cp4.first() == p3);
   BOOST_CHECK(cp4.second() == p4);
   BOOST_CHECK(cp5.first() == p1);
   BOOST_CHECK(cp5.second() == p2);
   swap(cp4,cp5);
   BOOST_CHECK(cp4.first() == p1);
   BOOST_CHECK(cp4.second() == p2);
   BOOST_CHECK(cp5.first() == p3);
   BOOST_CHECK(cp5.second() == p4);
 }
 //
-// instanciate some compressed pairs:
+// tests for case where one or both 
-#ifdef __MWERKS__
+// parameters are reference types:
-template class compressed_pair<int, double>;
+//
-template class compressed_pair<int, int>;
+template <class T1, class T2>
-template class compressed_pair<empty_UDT, int>;
+struct compressed_pair_reference_tester
-template class compressed_pair<int, empty_UDT>;
+{
-template class compressed_pair<empty_UDT, empty_UDT>;
+   // define the types we need:
-template class compressed_pair<empty_UDT, empty_POD_UDT>;
+   typedef T1                                                 first_type;
-#else
+   typedef T2                                                 second_type;
-template class boost::compressed_pair<int, double>;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
-template class boost::compressed_pair<int, int>;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
-template class boost::compressed_pair<empty_UDT, int>;
+   // define our test proc:
-template class boost::compressed_pair<int, empty_UDT>;
+   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
-template class boost::compressed_pair<empty_UDT, empty_UDT>;
+};
 template class boost::compressed_pair<empty_UDT, empty_POD_UDT>;
 #endif
 template <class T1, class T2>
 void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
 {
 #ifndef __GNUC__
   // gcc 2.90 can't cope with function scope using
   // declarations, and generates an internal compiler error...
   using std::swap;
 #endif
   // both param construct:
   boost::compressed_pair<T1,T2> cp4(p1, p2);
   BOOST_CHECK(cp4.first() == p1);
   BOOST_CHECK(cp4.second() == p2);
   boost::compressed_pair<T1,T2> cp5(p3, p4);
   BOOST_CHECK(cp5.first() == p3);
   BOOST_CHECK(cp5.second() == p4);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
   BOOST_CHECK(cpr1.first() == p1);
   BOOST_CHECK(cpr1.second() == p2);
   // copy construct:
   boost::compressed_pair<T1,T2> cp6(cp4);
   BOOST_CHECK(cp6.first() == p1);
   BOOST_CHECK(cp6.second() == p2);
   // assignment:
   // VC6 bug:
   // When second() is an empty class, VC6 performs the
   // assignment by doing a memcpy - even though the empty
   // class is really a zero sized base class, the result
   // is that the memory of first() gets trampled over.
   // Similar arguments apply to the case that first() is 
   // an empty base class.
   // Strangely the problem is dependent upon the compiler
   // settings - some generate the problem others do not.
   cp4.first() = p3;
   cp4.second() = p4;
   BOOST_CHECK(cp4.first() == p3);
   BOOST_CHECK(cp4.second() == p4);
 }
 //
 // supplimentary tests for case where first arg only is a reference type:
 //
 template <class T1, class T2>
 struct compressed_pair_reference1_tester
 {
   // define the types we need:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   // define our test proc:
   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
 };
 template <class T1, class T2>
 void compressed_pair_reference1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
 {
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
+   // first param construct:
-// now some for which only a few specific members can be instantiated,
+   boost::compressed_pair<T1,T2> cp2(p1);
-// first references:
+   cp2.second() = p2;
-template double& compressed_pair<double, int&>::first();
+   BOOST_CHECK(cp2.first() == p1);
-template int& compressed_pair<double, int&>::second();
+   BOOST_CHECK(cp2.second() == p2);
 template compressed_pair<double, int&>::compressed_pair(int&);
 template compressed_pair<double, int&>::compressed_pair(call_traits<double>::param_type,int&);
 //
 // and then arrays:
 #ifndef __MWERKS__
 #ifndef __BORLANDC__
 template call_traits<int[2]>::reference compressed_pair<double, int[2]>::second();
 #endif
-template call_traits<double>::reference compressed_pair<double, int[2]>::first();
+}
-template compressed_pair<double, int[2]>::compressed_pair(const double&);
+//
-template compressed_pair<double, int[2]>::compressed_pair();
+// supplimentary tests for case where second arg only is a reference type:
-#endif // __MWERKS__
+//
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T1, class T2>
 struct compressed_pair_reference2_tester
 {
   // define the types we need:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   // define our test proc:
   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
 };
 template <class T1, class T2>
 void compressed_pair_reference2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
 {
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   // second param construct:
   boost::compressed_pair<T1,T2> cp3(p2);
   cp3.first() = p1;
   BOOST_CHECK(cp3.second() == p2);
   BOOST_CHECK(cp3.first() == p1);
 #endif
 }
 //
 // tests for where one or the other parameter is an array:
 //
 template <class T1, class T2>
 struct compressed_pair_array1_tester
 {
   // define the types we need:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   // define our test proc:
   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
 };
 template <class T1, class T2>
 void compressed_pair_array1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
 {
  // default construct:
   boost::compressed_pair<T1,T2> cp1;
   // second param construct:
   boost::compressed_pair<T1,T2> cp3(p2);
   cp3.first()[0] = p1[0];
   BOOST_CHECK(cp3.second() == p2);
   BOOST_CHECK(cp3.first()[0] == p1[0]);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp3;
   BOOST_CHECK(cpr1.first()[0] == p1[0]);
   BOOST_CHECK(cpr1.second() == p2);
   BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
 }
 template <class T1, class T2>
 struct compressed_pair_array2_tester
 {
   // define the types we need:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   // define our test proc:
   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
 };
 template <class T1, class T2>
 void compressed_pair_array2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
 {
   // default construct:
   boost::compressed_pair<T1,T2> cp1;
   // first param construct:
   boost::compressed_pair<T1,T2> cp2(p1);
   cp2.second()[0] = p2[0];
   BOOST_CHECK(cp2.first() == p1);
   BOOST_CHECK(cp2.second()[0] == p2[0]);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp2;
   BOOST_CHECK(cpr1.first() == p1);
   BOOST_CHECK(cpr1.second()[0] == p2[0]);
   BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
 }
 template <class T1, class T2>
 struct compressed_pair_array_tester
 {
   // define the types we need:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   // define our test proc:
   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
 };
 template <class T1, class T2>
 void compressed_pair_array_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
 {
   // default construct:
   boost::compressed_pair<T1,T2> cp1;
   cp1.first()[0] = p1[0];
   cp1.second()[0] = p2[0];
   BOOST_CHECK(cp1.first()[0] == p1[0]);
   BOOST_CHECK(cp1.second()[0] == p2[0]);
   // check const members:
   const boost::compressed_pair<T1,T2>& cpr1 = cp1;
   BOOST_CHECK(cpr1.first()[0] == p1[0]);
   BOOST_CHECK(cpr1.second()[0] == p2[0]);
   BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
   BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
 }
 int test_main(int, char *[])
 {
   // declare some variables to pass to the tester:
   non_empty1 ne1(2);
   non_empty1 ne2(3);
   non_empty2 ne3(4);
   non_empty2 ne4(5);
   empty_POD_UDT  e1;
   empty_UDT      e2;
   // T1 != T2, both non-empty
   compressed_pair_tester<non_empty1,non_empty2>::test(ne1, ne3, ne2, ne4);
   // T1 != T2, T2 empty
   compressed_pair_tester<non_empty1,empty_POD_UDT>::test(ne1, e1, ne2, e1);
   // T1 != T2, T1 empty
   compressed_pair_tester<empty_POD_UDT,non_empty2>::test(e1, ne3, e1, ne4);
   // T1 != T2, both empty
   compressed_pair_tester<empty_POD_UDT,empty_UDT>::test(e1, e2, e1, e2);
   // T1 == T2, both non-empty
   compressed_pair_tester<non_empty1,non_empty1>::test(ne1, ne1, ne2, ne2);
   // T1 == T2, both empty
   compressed_pair_tester<empty_UDT,empty_UDT>::test(e2, e2, e2, e2);
   // test references:
   // T1 != T2, both non-empty
   compressed_pair_reference_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
   compressed_pair_reference_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
   compressed_pair_reference1_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
   compressed_pair_reference2_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
   // T1 != T2, T2 empty
   compressed_pair_reference_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
   compressed_pair_reference1_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
   // T1 != T2, T1 empty
   compressed_pair_reference_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
   compressed_pair_reference2_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
   // T1 == T2, both non-empty
   compressed_pair_reference_tester<non_empty1&,non_empty1&>::test(ne1, ne1, ne2, ne2);
   // tests arrays:
   non_empty1 nea1[2];
   non_empty1 nea2[2];
   non_empty2 nea3[2];
   non_empty2 nea4[2];
   nea1[0] = non_empty1(5);
   nea2[0] = non_empty1(6);
   nea3[0] = non_empty2(7);
   nea4[0] = non_empty2(8);
   // T1 != T2, both non-empty
   compressed_pair_array1_tester<non_empty1[2],non_empty2>::test(nea1, ne3, nea2, ne4);
   compressed_pair_array2_tester<non_empty1,non_empty2[2]>::test(ne1, nea3, ne2, nea4);
   compressed_pair_array_tester<non_empty1[2],non_empty2[2]>::test(nea1, nea3, nea2, nea4);
   // T1 != T2, T2 empty
   compressed_pair_array1_tester<non_empty1[2],empty_POD_UDT>::test(nea1, e1, nea2, e1);
   // T1 != T2, T1 empty
   compressed_pair_array2_tester<empty_POD_UDT,non_empty2[2]>::test(e1, nea3, e1, nea4);
   // T1 == T2, both non-empty
   compressed_pair_array_tester<non_empty1[2],non_empty1[2]>::test(nea1, nea1, nea2, nea2);
   return 0;
 }
 unsigned int expected_failures = 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
@ -0,0 +1,40 @@
 #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
 //
 //  current_function_test.cpp - a test for boost/current_function.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 #include <boost/current_function.hpp>
 #include <boost/config.hpp>
 #include <cstdio>
 void message(char const * file, long line, char const * func, char const * msg)
 {
 #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)
 int main()
 {
    MESSAGE("assertion failed");
    return 0;
 }
--- 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/generator_iterator.htm
+++ b/generator_iterator.htm
@ -0,0 +1,163 @@
 <!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>Generator Iterator Adaptor Documentation</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
  <img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle"
  width="277" height="86">
  <h1>Generator Iterator Adaptor</h1>
  <p>Defined in header <a href=
  "../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>
  <p>The generator iterator adaptor makes it easier to create custom input
  iterators from 0-ary functions and function objects. The adaptor takes a
  <a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> and
  creates a model of <a href=
  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>. Each
  increment retrieves an item from the generator and makes it available to be
  retrieved by dereferencing. The motivation for this iterator is that some
  concepts can be more naturally expressed as a generator, while most STL
  algorithms expect an iterator. An example is the <a href=
  "../random/index.html">Random Number</a> library.</p>
  <h2>Synopsis</h2>
  <blockquote>
    <pre>
 namespace boost {
  template &lt;class Generator&gt;
  class generator_iterator_policies;
  template &lt;class Generator&gt;
  class generator_iterator_generator;
  template &lt;class Generator&gt;
  typename generator_iterator_generator&lt;Generator&gt;::type
  make_generator_iterator(Generator &amp; gen);
 }
 </pre>
  </blockquote>
  <hr>
  <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
  class is the Generator function object type that is being wrapped. The
  generator iterator adaptor only holds a reference (or pointer) to the
  function object, therefore the function object must outlive the generator
  iterator adaptor constructed from it.</p>
  <pre>
 template &lt;class Generator&gt;
 class generator_iterator_generator
 {
 public:
  typedef <i>unspecified</i> type; // the resulting generator iterator type 
 }
 </pre>
  <h3>Template Parameters</h3>
  <table border summary="">
    <tr>
      <th>Parameter</th>
      <th>Description</th>
    </tr>
    <tr>
      <td><tt><a href=
      "http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>
      <td>The generator (0-ary function object) type being wrapped. The
      return type of the function must be defined as
      <tt>Generator::result_type</tt>. The function object must be a model of
      <a href=
      "http://www.sgi.com/tech/stl/Generator.html">Generator</a>.</td>
    </tr>
  </table>
  <h3>Concept Model</h3>
  <p>The generator iterator class is a model of <a href=
  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.</p>
  <h3>Members</h3>
  <p>The generator iterator implements the member functions and operators
  required of the <a href=
  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
  concept.<br></p>
  <hr>
  <h2><a name="make_generator_iterator" id="make_generator_iterator">The
  Generator Iterator Object Generator</a></h2>
  <p>The <tt>make_generator_iterator()</tt> function provides a convenient
  way to create generator iterator objects. The function saves the user the
  trouble of explicitly writing out the iterator types.</p>
  <blockquote>
    <pre>
 template &lt;class Generator&gt;
 typename generator_iterator_generator&lt;Generator&gt;::type
 make_generator_iterator(Generator &amp; gen);
 </pre>
  </blockquote>
  <hr>
  <h3>Example</h3>
  <p>The following program shows how <code>generator_iterator</code>
  transforms a generator into an input iterator.</p>
  <blockquote>
    <pre>
 #include &lt;iostream&gt;
 #include &lt;boost/generator_iterator.hpp&gt;
 class my_generator
 {
 public:
  typedef int result_type;
  my_generator() : state(0) { }
  int operator()() { return ++state; }
 private:
  int state;
 };
 int main()
 {
  my_generator gen;
  boost::generator_iterator_generator&lt;my_generator&gt;::type it = boost::make_generator_iterator(gen);
  for(int i = 0; i &lt; 10; ++i, ++it)
    std::cout &lt;&lt; *it &lt;&lt; std::endl;
 }
 </pre>
  </blockquote>
  <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>
  <p><i>Copyright &copy; 2001 <a href=
  "http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a></i></p>
  <p><i>Distributed under the Boost Software License, Version 1.0. (See
  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
  copy at <a href=
  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
 </body>
 </html>
--- a/in_place_factories.html
+++ b/in_place_factories.html
@ -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
@ -0,0 +1,50 @@
 //
 //  boost/assert.hpp - BOOST_ASSERT(expr)
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2007 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 //  Note: There are no include guards. This is intentional.
 //
 //  See http://www.boost.org/libs/utility/assert.html for documentation.
 //
 #undef BOOST_ASSERT
 #if defined(BOOST_DISABLE_ASSERTS)
 # define BOOST_ASSERT(expr) ((void)0)
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER)
 #include <boost/current_function.hpp>
 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)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 #else
 # include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
 # define BOOST_ASSERT(expr) assert(expr)
 #endif
 #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
@ -0,0 +1,69 @@
 #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
 #define BOOST_CHECKED_DELETE_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/checked_delete.hpp
 //
 //  Copyright (c) 2002, 2003 Peter Dimov
 //  Copyright (c) 2003 Daniel Frey
 //  Copyright (c) 2003 Howard Hinnant
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/utility/checked_delete.html for documentation.
 //
 namespace boost
 {
 // verify that types are complete for increased safety
 template<class T> inline void checked_delete(T * x)
 {
    // intentionally complex - simplification causes regressions
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
 }
 template<class T> inline void checked_array_delete(T * x)
 {
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete [] x;
 }
 template<class T> struct checked_deleter
 {
    typedef void result_type;
    typedef T * argument_type;
    void operator()(T * x) const
    {
        // boost:: disables ADL
        boost::checked_delete(x);
    }
 };
 template<class T> struct checked_array_deleter
 {
    typedef void result_type;
    typedef T * argument_type;
    void operator()(T * x) const
    {
        boost::checked_array_delete(x);
    }
 };
 } // namespace boost
 #endif  // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
--- 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
@ -0,0 +1,67 @@
 #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
 #define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 //
 //  boost/current_function.hpp - BOOST_CURRENT_FUNCTION
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 //  http://www.boost.org/libs/utility/current_function.html
 //
 namespace boost
 {
 namespace detail
 {
 inline void current_function_helper()
 {
 #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__
 #elif defined(__FUNCSIG__)
 # define BOOST_CURRENT_FUNCTION __FUNCSIG__
 #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__
 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
 # define BOOST_CURRENT_FUNCTION __func__
 #else
 # define BOOST_CURRENT_FUNCTION "(unknown)"
 #endif
 }
 } // namespace detail
 } // namespace boost
 #endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
--- 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,31 +21,44 @@
 #ifndef BOOST_CONFIG_HPP
 #include <boost/config.hpp>
 #endif
 #include <cstddef>
-#ifndef BOOST_TYPE_TRAITS_HPP
+#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits.hpp>
+#include <boost/type_traits/is_pointer.hpp>
-#endif
+#include <boost/detail/workaround.hpp>
 namespace boost{
 namespace detail{
-template <typename T, bool isp, bool b1, bool b2>
+template <typename T, bool small_>
 struct ct_imp2
 {
   typedef const T& param_type;
 };
 template <typename T>
 struct ct_imp2<T, true>
 {
   typedef const T param_type;
 };
 template <typename T, bool isp, bool b1>
 struct ct_imp
 {
   typedef const T& param_type;
 };
 template <typename T, bool isp>
-struct ct_imp<T, isp, true, true>
+struct ct_imp<T, isp, true>
 {
-   typedef T const param_type;
+   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
 };
-template <typename T, bool b1, bool b2>
+template <typename T, bool b1>
-struct ct_imp<T, true, b1, b2>
+struct ct_imp<T, true, b1>
 {
-   typedef T const param_type;
+   typedef const T param_type;
 };
 }
@ -64,7 +76,11 @@ 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<T, ::boost::is_pointer<typename remove_const<T>::type>::value, ::boost::is_arithmetic<typename remove_const<T>::type>::value, sizeof(T) <= sizeof(void*)>::param_type param_type;
+   typedef typename boost::detail::ct_imp<
      T,
      ::boost::is_pointer<T>::value,
      ::boost::is_arithmetic<T>::value
   >::param_type param_type;
 };
 template <typename T>
@ -76,7 +92,7 @@ struct call_traits<T&>
   typedef T& param_type;  // hh removed const
 };
-#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
+#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
@ -105,8 +121,17 @@ struct call_traits<T&const volatile>
   typedef const T& const_reference;
   typedef T& param_type;  // hh removed const
 };
 #endif
 template <typename T>
 struct call_traits< T * >
 {
   typedef T * value_type;
   typedef T * & reference;
   typedef T * const & const_reference;
   typedef T * const param_type;  // hh removed const
 };
 #endif
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
 template <typename T, std::size_t N>
 struct call_traits<T [N]>
 {
@ -132,6 +157,7 @@ public:
   typedef const array_type& const_reference;
   typedef const T* const param_type;
 };
 #endif
 }
--- 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,23 @@
 #define BOOST_DETAIL_COMPRESSED_PAIR_HPP
 #include <algorithm>
 #ifndef BOOST_TYPE_TRAITS_HPP
 #include <boost/type_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
 {
 template <class T1, class T2>
 class compressed_pair;
 // compressed_pair
 namespace details
@ -75,7 +84,9 @@ namespace details
   template <typename T>
   inline void cp_swap(T& t1, T& t2)
   {
 #ifndef __GNUC__
      using std::swap;
 #endif
      swap(t1, t2);
   }
@ -99,10 +110,10 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_(x), second_(y) {}
-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_(x) {}
-      explicit compressed_pair_imp(second_param_type y)
+      compressed_pair_imp(second_param_type y)
         : second_(y) {}
      first_reference       first()       {return first_;}
@ -111,10 +122,10 @@ namespace details
      second_reference       second()       {return second_;}
      second_const_reference second() const {return second_;}
-      void swap(compressed_pair_imp& y)
+      void swap(::boost::compressed_pair<T1, T2>& y)
      {
-         cp_swap(first_, y.first_);
+         cp_swap(first_, y.first());
-         cp_swap(second_, y.second_);
+         cp_swap(second_, y.second());
      }
   private:
      first_type first_;
@ -125,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;
@ -142,10 +153,10 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_type(x), second_(y) {}
-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_type(x) {}
-      explicit compressed_pair_imp(second_param_type y)
+      compressed_pair_imp(second_param_type y)
         : second_(y) {}
      first_reference       first()       {return *this;}
@ -154,10 +165,10 @@ namespace details
      second_reference       second()       {return second_;}
      second_const_reference second() const {return second_;}
-      void swap(compressed_pair_imp& y)
+      void swap(::boost::compressed_pair<T1,T2>& y)
      {
         // no need to swap empty base class:
-         cp_swap(second_, y.second_);
+         cp_swap(second_, y.second());
      }
   private:
      second_type second_;
@ -167,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;
@ -184,10 +195,10 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : second_type(y), first_(x) {}
-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_(x) {}
-      explicit compressed_pair_imp(second_param_type y)
+      compressed_pair_imp(second_param_type y)
         : second_type(y) {}
      first_reference       first()       {return first_;}
@ -196,10 +207,10 @@ namespace details
      second_reference       second()       {return *this;}
      second_const_reference second() const {return *this;}
-      void swap(compressed_pair_imp& y)
+      void swap(::boost::compressed_pair<T1,T2>& y)
      {
         // no need to swap empty base class:
-         cp_swap(first_, y.first_);
+         cp_swap(first_, y.first());
      }
   private:
@ -210,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;
@ -228,10 +239,10 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_type(x), second_type(y) {}
-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_type(x) {}
-      explicit compressed_pair_imp(second_param_type y)
+      compressed_pair_imp(second_param_type y)
         : second_type(y) {}
      first_reference       first()       {return *this;}
@ -241,16 +252,19 @@ namespace details
      second_const_reference second() const {return *this;}
      //
      // no need to swap empty bases:
-      void swap(compressed_pair_imp&) {}
+      void swap(::boost::compressed_pair<T1,T2>&) {}
   };
   // 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;
@ -264,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) {}
-      explicit compressed_pair_imp(first_param_type x)
+      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(compressed_pair_imp&) {}
+      void swap(::boost::compressed_pair<T1,T2>&) {}
   private:
      T2 m_second;
   };
   // 5    T1 == T2 and are not empty:   //JM
@ -300,7 +315,7 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_(x), second_(y) {}
-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_(x), second_(x) {}
      first_reference       first()       {return first_;}
@ -309,10 +324,10 @@ namespace details
      second_reference       second()       {return second_;}
      second_const_reference second() const {return second_;}
-      void swap(compressed_pair_imp<T1, T2, 5>& y)
+      void swap(::boost::compressed_pair<T1, T2>& y)
      {
-         cp_swap(first_, y.first_);
+         cp_swap(first_, y.first());
-         cp_swap(second_, y.second_);
+         cp_swap(second_, y.second());
      }
   private:
      first_type first_;
@ -396,7 +411,10 @@ public:
            compressed_pair() : base() {}
            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
-   explicit compressed_pair(first_param_type x) : base(x) {}
+#if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530))
   explicit 
 #endif
      compressed_pair(first_param_type x) : base(x) {}
   first_reference       first()       {return base::first();}
   first_const_reference first() const {return base::first();}
@ -404,7 +422,7 @@ public:
   second_reference       second()       {return base::second();}
   second_const_reference second() const {return base::second();}
-   void swap(compressed_pair& y) { base::swap(y); }
+   void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
 };
 template <class T1, class T2>
@ -417,6 +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,14 +1,21 @@
 //  (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
 //
 /* Release notes:
   01st October 2000:
      Fixed call_traits on VC6, using "poor man's partial specialisation",
      using ideas taken from "Generative programming" by Krzysztof Czarnecki 
      & Ulrich Eisenecker.
 */
 #ifndef BOOST_OB_CALL_TRAITS_HPP
 #define BOOST_OB_CALL_TRAITS_HPP
@ -16,12 +23,135 @@
 #include <boost/config.hpp>
 #endif
-#ifndef BOOST_TYPE_TRAITS_HPP
+#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
+#include <boost/type_traits/arithmetic_traits.hpp>
 #endif
 #ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
 #include <boost/type_traits/composite_traits.hpp>
 #endif
 namespace boost{
 #ifdef BOOST_MSVC6_MEMBER_TEMPLATES
 //
 // use member templates to emulate
 // partial specialisation:
 //
 namespace detail{
 template <class T>
 struct standard_call_traits
 {
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef const T& param_type;
 };
 template <class T>
 struct simple_call_traits
 {
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef const T param_type;
 };
 template <class T>
 struct reference_call_traits
 {
   typedef T value_type;
   typedef T reference;
   typedef T const_reference;
   typedef T param_type;
 };
 template <bool pointer, bool arithmetic, bool reference>
 struct call_traits_chooser
 {
   template <class T>
   struct rebind
   {
      typedef standard_call_traits<T> type;
   };
 };
 template <>
 struct call_traits_chooser<true, false, false>
 {
   template <class T>
   struct rebind
   {
      typedef simple_call_traits<T> type;
   };
 };
 template <>
 struct call_traits_chooser<false, false, true>
 {
   template <class T>
   struct rebind
   {
      typedef reference_call_traits<T> type;
   };
 };
 template <bool size_is_small> 
 struct call_traits_sizeof_chooser2
 {
   template <class T>
   struct small_rebind
   {
      typedef simple_call_traits<T> small_type;
   };
 };
 template<> 
 struct call_traits_sizeof_chooser2<false>
 {
   template <class T>
   struct small_rebind
   {
      typedef standard_call_traits<T> small_type;
   };
 };
 template <>
 struct call_traits_chooser<false, true, false>
 {
   template <class T>
   struct rebind
   {
      enum { sizeof_choice = (sizeof(T) <= sizeof(void*)) };
      typedef call_traits_sizeof_chooser2<(sizeof(T) <= sizeof(void*))> chooser;
      typedef typename chooser::template small_rebind<T> bound_type;
      typedef typename bound_type::small_type type;
   };
 };
 } // namespace detail
 template <typename T>
 struct call_traits
 {
 private:
    typedef detail::call_traits_chooser<
         ::boost::is_pointer<T>::value,
         ::boost::is_arithmetic<T>::value, 
         ::boost::is_reference<T>::value
      > chooser;
   typedef typename chooser::template rebind<T> bound_type;
   typedef typename bound_type::type call_traits_type;
 public:
   typedef typename call_traits_type::value_type       value_type;
   typedef typename call_traits_type::reference        reference;
   typedef typename call_traits_type::const_reference  const_reference;
   typedef typename call_traits_type::param_type       param_type;
 };
 #else
 //
 // sorry call_traits is completely non-functional
 // blame your broken compiler:
 //
 template <typename T>
 struct call_traits
 {
@ -31,6 +161,8 @@ struct call_traits
   typedef const T& param_type;
 };
 #endif // member templates
 }
 #endif // BOOST_OB_CALL_TRAITS_HPP
--- a/include/boost/detail/ob_compressed_pair.hpp
+++ b/include/boost/detail/ob_compressed_pair.hpp
@ -1,13 +1,18 @@
 //  (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:
   20 Jan 2001:
        Fixed obvious bugs (David Abrahams)
   07 Oct 2000:
      Added better single argument constructor support.
   03 Oct 2000:
      Added VC6 support (JM).
   23rd July 2000:
      Additional comments added. (JM)
   Jan 2000:
@ -20,8 +25,11 @@
 #define BOOST_OB_COMPRESSED_PAIR_HPP
 #include <algorithm>
-#ifndef BOOST_TYPE_TRAITS_HPP
+#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
-#include <boost/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>
@ -29,6 +37,426 @@
 namespace boost
 {
 #ifdef BOOST_MSVC6_MEMBER_TEMPLATES
 //
 // use member templates to emulate
 // partial specialisation.  Note that due to
 // problems with overload resolution with VC6
 // each of the compressed_pair versions that follow
 // have one template single-argument constructor
 // in place of two specific constructors:
 //
 template <class T1, class T2>
 class compressed_pair;
 namespace detail{
 template <class A, class T1, class T2>
 struct best_conversion_traits
 {
   typedef char one;
   typedef char (&two)[2];
   static A a;
   static one test(T1);
   static two test(T2);
   enum { value = sizeof(test(a)) };
 };
 template <int>
 struct init_one;
 template <>
 struct init_one<1>
 {
   template <class A, class T1, class T2>
   static void init(const A& a, T1* p1, T2*)
   {
      *p1 = a;
   }
 };
 template <>
 struct init_one<2>
 {
   template <class A, class T1, class T2>
   static void init(const A& a, T1*, T2* p2)
   {
      *p2 = a;
   }
 };
 // T1 != T2, both non-empty
 template <class T1, class T2>
 class compressed_pair_0
 {
 private:
   T1 _first;
   T2 _second;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_0() : _first(), _second() {}
            compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
   template <class A>
   explicit compressed_pair_0(const A& val)
   {
      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
   }
   compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
      : _first(x.first()), _second(x.second()) {}
 #if 0
  compressed_pair_0& operator=(const compressed_pair_0& x) {
    cout << "assigning compressed pair 0" << endl;
    _first = x._first;
    _second = x._second;
    cout << "finished assigning compressed pair 0" << endl;
    return *this;
  }
 #endif
   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }
   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }
   void swap(compressed_pair_0& y)
   {
      using std::swap;
      swap(_first, y._first);
      swap(_second, y._second);
   }
 };
 // T1 != T2, T2 empty
 template <class T1, class T2>
 class compressed_pair_1 : T2
 {
 private:
   T1 _first;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_1() : T2(), _first() {}
            compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}
   template <class A>
   explicit compressed_pair_1(const A& val)
   {
      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
   }
   compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
      : T2(x.second()), _first(x.first()) {}
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
  // Total weirdness. If the assignment to _first is moved after
  // the call to the inherited operator=, then this breaks graph/test/graph.cpp
  // by way of iterator_adaptor.
  compressed_pair_1& operator=(const compressed_pair_1& x) {
    _first = x._first;
    T2::operator=(x);
    return *this;
  }
 #endif
   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }
   second_reference       second()       { return *this; }
   second_const_reference second() const { return *this; }
   void swap(compressed_pair_1& y)
   {
      // no need to swap empty base class:
      using std::swap;
      swap(_first, y._first);
   }
 };
 // T1 != T2, T1 empty
 template <class T1, class T2>
 class compressed_pair_2 : T1
 {
 private:
   T2 _second;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_2() : T1(), _second() {}
            compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
   template <class A>
   explicit compressed_pair_2(const A& val)
   {
      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
   }
   compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
      : T1(x.first()), _second(x.second()) {}
 #if 0
  compressed_pair_2& operator=(const compressed_pair_2& x) {
    cout << "assigning compressed pair 2" << endl;
    T1::operator=(x);
    _second = x._second;
    cout << "finished assigning compressed pair 2" << endl;
    return *this;
  }
 #endif
   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }
   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }
   void swap(compressed_pair_2& y)
   {
      // no need to swap empty base class:
      using std::swap;
      swap(_second, y._second);
   }
 };
 // T1 != T2, both empty
 template <class T1, class T2>
 class compressed_pair_3 : T1, T2
 {
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_3() : T1(), T2() {}
            compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
   template <class A>
   explicit compressed_pair_3(const A& val)
   {
      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));
   }
   compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
      : T1(x.first()), T2(x.second()) {}
   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }
   second_reference       second()       { return *this; }
   second_const_reference second() const { return *this; }
   void swap(compressed_pair_3& y)
   {
      // no need to swap empty base classes:
   }
 };
 // T1 == T2, and empty
 template <class T1, class T2>
 class compressed_pair_4 : T1
 {
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   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 y) : T1(x), m_second(y) {}
   // only one single argument constructor since T1 == T2
   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()), m_second(x.second()) {}
   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }
   second_reference       second()       { return m_second; }
   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
 template <class T1, class T2>
 class compressed_pair_5
 {
 private:
   T1 _first;
   T2 _second;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_5() : _first(), _second() {}
            compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}
   // only one single argument constructor since T1 == T2
   explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}
   compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c) 
      : _first(c.first()), _second(c.second()) {}
   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }
   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }
   void swap(compressed_pair_5& y)
   {
      using std::swap;
      swap(_first, y._first);
      swap(_second, y._second);
   }
 };
 template <bool e1, bool e2, bool same>
 struct compressed_pair_chooser
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_0<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<false, true, false>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_1<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<true, false, false>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_2<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<true, true, false>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_3<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<true, true, true>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_4<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<false, false, true>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_5<T1, T2> type;
   };
 };
 template <class T1, class T2>
 struct compressed_pair_traits
 {
 private:
   typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;
   typedef typename chooser::template rebind<T1, T2> bound_type;
 public:
   typedef typename bound_type::type type;
 };
 } // namespace detail
 template <class T1, class T2>
 class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type
 {
 private:
   typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair() : base_type() {}
            compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}
   template <class A>
   explicit compressed_pair(const A& x) : base_type(x){}
   first_reference       first()       { return base_type::first(); }
   first_const_reference first() const { return base_type::first(); }
   second_reference       second()       { return base_type::second(); }
   second_const_reference second() const { return base_type::second(); }
 };
 template <class T1, class T2>
 inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
 {
   x.swap(y);
 }
 #else
 // no partial specialisation, no member templates:
 template <class T1, class T2>
 class compressed_pair
@ -72,7 +500,11 @@ inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
   x.swap(y);
 }
 #endif
 } // boost
 #endif // BOOST_OB_COMPRESSED_PAIR_HPP
--- a/include/boost/exception.hpp
+++ b/include/boost/exception.hpp
@ -0,0 +1,11 @@
 //Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
 //Distributed under the Boost Software License, Version 1.0. (See accompanying
 //file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #ifndef UUID_1D94A7C6054E11DB9804B622A1EF5492
 #define UUID_1D94A7C6054E11DB9804B622A1EF5492
 #error The header <boost/exception.hpp> has been deprecated. Please #include <boost/exception/all.hpp> instead.
 #endif
--- a/include/boost/generator_iterator.hpp
+++ b/include/boost/generator_iterator.hpp
@ -0,0 +1,80 @@
 // (C) Copyright Jens Maurer 2001.
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // Revision History:
 // 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/iterator_facade.hpp>
 #include <boost/ref.hpp>
 namespace boost {
 template<class Generator>
 class generator_iterator
  : public iterator_facade<
        generator_iterator<Generator>
      , typename Generator::result_type
      , single_pass_traversal_tag
      , typename Generator::result_type const&
    >
 {
    typedef iterator_facade<
        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)()) {}
    void increment()
    {
        m_value = (*m_g)();
    }
    const typename Generator::result_type&
    dereference() const
    {
        return m_value;
    }
    bool equal(generator_iterator const& y) const
    {
        return this->m_g == y.m_g && this->m_value == y.m_value;
    }
 private:
    Generator* m_g;
    typename Generator::result_type m_value;
 };
 template<class Generator>
 struct generator_iterator_generator
 {
  typedef generator_iterator<Generator> type;
 };
 template <class Generator>
 inline generator_iterator<Generator>
 make_generator_iterator(Generator & gen)
 {
  typedef generator_iterator<Generator> result_t;
  return result_t(&gen);
 }
 } // namespace boost
 #endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
--- 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
--- a/include/boost/ref.hpp
+++ b/include/boost/ref.hpp
@ -0,0 +1,189 @@
 #ifndef BOOST_REF_HPP_INCLUDED
 #define BOOST_REF_HPP_INCLUDED
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # 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 Jarvi (jaakko.jarvi@cs.utu.fi)
 //  Copyright (C) 2001, 2002 Peter Dimov
 //  Copyright (C) 2002 David Abrahams
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/ref.html for documentation.
 //
 namespace boost
 {
 template<class T> class reference_wrapper
 { 
 public:
    typedef T type;
 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1300 )
    explicit reference_wrapper(T& t): t_(&t) {}
 #else
    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
 #endif
    operator T& () const { return *t_; }
    T& get() const { return *t_; }
    T* get_pointer() const { return t_; }
 private:
    T* t_;
 };
 # if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
 #  define BOOST_REF_CONST
 # else
 #  define BOOST_REF_CONST const
 # endif
 template<class T> inline reference_wrapper<T> BOOST_REF_CONST ref(T & t)
 { 
    return reference_wrapper<T>(t);
 }
 template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const & t)
 {
    return reference_wrapper<T const>(t);
 }
 # undef BOOST_REF_CONST
 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 class is_reference_wrapper
    : public mpl::false_
 {
 };
 template<typename T>
 class unwrap_reference
 {
 public:
    typedef T type;
 };
 #  define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \
 template<typename T> \
 class is_reference_wrapper< X > \
    : public mpl::true_ \
 { \
 }; \
 \
 template<typename T> \
 class unwrap_reference< X > \
 { \
 public: \
    typedef T type; \
 }; \
 /**/
 AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T>)
 #if !defined(BOOST_NO_CV_SPECIALIZATIONS)
 AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const)
 AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> volatile)
 AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const volatile)
 #endif
 #  undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF
 # else // no partial specialization
 } // namespace boost
 #include <boost/type.hpp>
 namespace boost
 {
 namespace detail
 {
  typedef char (&yes_reference_wrapper_t)[1];
  typedef char (&no_reference_wrapper_t)[2];
  no_reference_wrapper_t is_reference_wrapper_test(...);
  template<typename T>
  yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper<T> >);
  template<bool wrapped>
  struct reference_unwrapper
  {
      template <class T>
      struct apply
      {
          typedef T type;
      };
  };
  template<>
  struct reference_unwrapper<true>
  {
      template <class T>
      struct apply
      {
          typedef typename T::type type;
      };
  };
 }
 template<typename T>
 class is_reference_wrapper
 {
 public:
    BOOST_STATIC_CONSTANT(
        bool, value = (
             sizeof(detail::is_reference_wrapper_test(type<T>()))
            == sizeof(detail::yes_reference_wrapper_t)));
    typedef ::boost::mpl::bool_<value> type;
 };
 template <typename T>
 class unwrap_reference
    : public detail::reference_unwrapper<
        is_reference_wrapper<T>::value
      >::template apply<T>
 {};
 # 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,69 +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
 //  Revision History
 //  26 Jan 00  protected noncopyable destructor added (Miki Jovanovic)
 //  10 Dec 99  next() and prior() templates added (Dave Abrahams)
 //  30 Aug 99  moved cast templates to cast.hpp (Beman Dawes)
 //   3 Aug 99  cast templates added
 //  20 Jul 99  name changed to utility.hpp 
 //   9 Jun 99  protected noncopyable default ctor
 //   2 Jun 99  Initial Version. Class noncopyable only contents (Dave Abrahams)
 #ifndef BOOST_UTILITY_HPP
 #define BOOST_UTILITY_HPP
-#include <boost/config.hpp>
+#include <boost/utility/addressof.hpp>
-#include <cstddef>            // for size_t
+#include <boost/utility/base_from_member.hpp>
-
+#include <boost/utility/binary.hpp>
-namespace boost
+#include <boost/utility/enable_if.hpp>
-{
+#include <boost/checked_delete.hpp>
-
+#include <boost/next_prior.hpp>
-//  next() and prior() template functions  -----------------------------------//
+#include <boost/noncopyable.hpp>
    //  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);
    //  Contributed by Dave Abrahams
    template <class T>
    T next(T x) { return ++x; }
    template <class T>
    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
@ -0,0 +1,102 @@
 // Copyright (C) 2002 Brad King (brad.king@kitware.com) 
 //                    Douglas Gregor (gregod@cs.rpi.edu)
 //
 // Copyright (C) 2002, 2008 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // 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
 # include <boost/config.hpp>
 # include <boost/detail/workaround.hpp>
 namespace boost
 {
 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
@ -0,0 +1,87 @@
 //  boost utility/base_from_member.hpp header file  --------------------------//
 //  Copyright 2001, 2003, 2004 Daryle Walker.  Use, modification, and
 //  distribution are subject to the Boost Software License, Version 1.0.  (See
 //  accompanying file LICENSE_1_0.txt or a copy at
 //  <http://www.boost.org/LICENSE_1_0.txt>.)
 //  See <http://www.boost.org/libs/utility/> for the library's home page.
 #ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
 #define BOOST_UTILITY_BASE_FROM_MEMBER_HPP
 #include <boost/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
 {
 //  Base-from-member class template  -----------------------------------------//
 // Helper to initialize a base object so a derived class can use this
 // object in the initialization of another base class.  Used by
 // Dietmar Kuehl from ideas by Ron Klatcho to solve the problem of a
 // base class needing to be initialized by a member.
 // Contributed by Daryle Walker
 template < typename MemberType, int UniqueID = 0 >
 class base_from_member
 {
 protected:
    MemberType  member;
    base_from_member()
        : member()
        {}
    BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
     BOOST_PRIVATE_CTR_DEF, _ )
 };  // boost::base_from_member
 }  // namespace boost
 // Undo any private macros
 #undef BOOST_PRIVATE_CTR_DEF
 #endif  // BOOST_UTILITY_BASE_FROM_MEMBER_HPP
--- a/include/boost/utility/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/lib/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/detail/in_place_factory_prefix.hpp
+++ b/include/boost/utility/detail/in_place_factory_prefix.hpp
@ -0,0 +1,36 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
 // Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
 #ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
 #define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
 #include <new>
 #include <cstddef>
 #include <boost/config.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/punctuation/paren.hpp>
 #include <boost/preprocessor/iteration/iterate.hpp>
 #include <boost/preprocessor/repetition/repeat.hpp>
 #include <boost/preprocessor/repetition/enum.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
 #define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN()
 #define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL(z,n,_) BOOST_PP_CAT(A,n) const& BOOST_PP_CAT(m_a,n);
 #define BOOST_MAX_INPLACE_FACTORY_ARITY 10
 #undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
 #endif
--- a/include/boost/utility/detail/in_place_factory_suffix.hpp
+++ b/include/boost/utility/detail/in_place_factory_suffix.hpp
@ -0,0 +1,23 @@
 // Copyright (C) 2003, Fernando Luis Cacciola Carballal.
 // Copyright (C) 2007, Tobias Schwinger.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 // See http://www.boost.org/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
 #ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
 #define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
 #undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT
 #undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL
 #undef BOOST_MAX_INPLACE_FACTORY_ARITY
 #undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
 #endif
--- a/include/boost/utility/detail/result_of_iterate.hpp
+++ b/include/boost/utility/detail/result_of_iterate.hpp
@ -0,0 +1,148 @@
 // 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)
 // As of N2588, C++0x result_of only supports function call
 // expressions of the form f(x). This precludes support for member
 // function pointers, which are invoked with expressions of the form
 // o->*f(x). This implementation supports both.
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 struct result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
    : mpl::if_<
          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
        , detail::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 {
 # define BOOST_RESULT_OF_STATIC_MEMBERS(z, n, _) \
     static T ## n t ## n; \
  /**/
 template<typename F BOOST_PP_COMMA_IF(BOOST_PP_ITERATION())
         BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),typename T)>
 class cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
 {
  static F f;
  BOOST_PP_REPEAT(BOOST_PP_ITERATION(), BOOST_RESULT_OF_STATIC_MEMBERS, _)
 public:
  typedef decltype(f(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),t))) type;
 };
 } // namespace detail 
 #else // defined(BOOST_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/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
 #ifndef BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
 #ifndef BOOST_PP_IS_ITERATING
 #include <boost/utility/detail/in_place_factory_prefix.hpp>
 namespace boost {
 class in_place_factory_base {} ;
 #define  BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
 #define  BOOST_PP_FILENAME_1 <boost/utility/in_place_factory.hpp>
 #include BOOST_PP_ITERATE()
 } // namespace boost
 #include <boost/utility/detail/in_place_factory_suffix.hpp>
 #define BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
 #else
 #define N BOOST_PP_ITERATION()
 #if N
 template< BOOST_PP_ENUM_PARAMS(N, class A) >
 #endif
 class BOOST_PP_CAT(in_place_factory,N)
  : 
  public in_place_factory_base
 {
 public:
  explicit BOOST_PP_CAT(in_place_factory,N)
      ( BOOST_PP_ENUM_BINARY_PARAMS(N,A,const& a) )
 #if N > 0
    : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
 #endif
  {}
  template<class T>
  void* apply(void* address
      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
  {
    return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
  }
  template<class T>
  void* apply(void* address, std::size_t n
      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
  {
    for(char* next = address = this->BOOST_NESTED_TEMPLATE apply<T>(address);
        !! --n;)
      this->BOOST_NESTED_TEMPLATE apply<T>(next = next+sizeof(T));
    return address; 
  }
  BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
 };
 #if N > 0
 template< BOOST_PP_ENUM_PARAMS(N, class A) >
 inline BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
 in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
 {
  return BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
      ( BOOST_PP_ENUM_PARAMS(N, a) );
 }
 #else
 inline in_place_factory0 in_place()
 {
  return in_place_factory0();
 }
 #endif
 #undef N
 #endif
 #endif
--- a/include/boost/utility/result_of.hpp
+++ b/include/boost/utility/result_of.hpp
@ -0,0 +1,100 @@
 // Boost result_of library
 //  Copyright Douglas Gregor 2004. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 // For more information, see http://www.boost.org/libs/utility
 #ifndef BOOST_RESULT_OF_HPP
 #define BOOST_RESULT_OF_HPP
 #include <boost/config.hpp>
 #include <boost/preprocessor/iteration/iterate.hpp> 
 #include <boost/preprocessor/punctuation/comma_if.hpp> 
 #include <boost/preprocessor/repetition/enum_params.hpp> 
 #include <boost/preprocessor/repetition/enum_shifted_params.hpp> 
 #include <boost/detail/workaround.hpp>
 #include <boost/mpl/has_xxx.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/or.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 #include <boost/type_traits/remove_cv.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/lib/optional for documentation.
 //
 // You are welcome to contact the author at:
 //  fernando_cacciola@hotmail.com
 //
 #ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
 #ifndef BOOST_PP_IS_ITERATING
 #include <boost/utility/detail/in_place_factory_prefix.hpp>
 namespace boost {
 class typed_in_place_factory_base {} ;
 #define  BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
 #define  BOOST_PP_FILENAME_1 <boost/utility/typed_in_place_factory.hpp>
 #include BOOST_PP_ITERATE()
 } // namespace boost
 #include <boost/utility/detail/in_place_factory_suffix.hpp>
 #define BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
 #else 
 #define N BOOST_PP_ITERATION()
 template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N,class A) >
 class BOOST_PP_CAT(typed_in_place_factory,N) 
  : 
  public typed_in_place_factory_base
 {
 public:
  typedef T value_type;
  explicit BOOST_PP_CAT(typed_in_place_factory,N) 
      ( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
 #if N > 0
    : BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
 #endif
  {}
  void* apply (void* address) const
  {
    return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
  }
  void* apply (void* address, std::size_t n) const
  {
    for(void* next = address = this->apply(address); !! --n;)
      this->apply(next = static_cast<char *>(next) + sizeof(T));
    return address; 
  }
  BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
 };
 template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N, class A) >
 inline BOOST_PP_CAT(typed_in_place_factory,N)<
    T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >
 in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
 {
  return BOOST_PP_CAT(typed_in_place_factory,N)< 
      T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >( BOOST_PP_ENUM_PARAMS(N, a) );
 }
 #undef N
 #endif
 #endif
--- a/include/boost/utility/value_init.hpp
+++ b/include/boost/utility/value_init.hpp
@ -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/index.htm
+++ b/index.htm
@ -1,72 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Boost Utility Library</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <table border="1" cellpadding="2" bgcolor="#007F7F">
  <tr>
    <td bgcolor="#FFFFFF"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
    <td><a href="../../index.htm"><font color="#FFFFFF" size="4" face="Arial">Home</font></a></td>
    <td><a href="../../libraries.htm"><font color="#FFFFFF" size="4" face="Arial">Libraries</font></a></td>
    <td><a href="../../people.htm"><font color="#FFFFFF" size="4" face="Arial">People</font></a></td>
    <td><a href="../../more/faq.htm"><font color="#FFFFFF" size="4" face="Arial">FAQ</font></a></td>
    <td><a href="../../more/index.htm"><font color="#FFFFFF" size="4" face="Arial">More</font></a></td>
  </tr>
 </table>
 <h1>Boost Utility Library</h1>
 <table border="1" cellpadding="5">
  <tr>
    <td><b><i>Header</i></b></td>
    <td><b><i>Contents</i></b></td>
  </tr>
  <tr>
    <td><a href="../../boost/utility.hpp"><code>boost/utility.hpp<br>
      </code></a><a href="utility.htm">[Documentation]</a></td>
    <td>Class <b>noncopyable</b> plus <b>next()</b> and <b>prior()</b> template
      functions.</td>
  </tr>
  <tr>
    <td><a href="../../boost/cast.hpp"><code>boost/cast.hpp</code></a><br>
      <a href="cast.htm">[Documentation]</a></td>
    <td><b>polymorphic_cast</b>, <b>implicit_cast</b>, and <b>numeric_cast</b>
      function templates.
      <p><i>[Beta.]</i></p>
    </td>
  </tr>
  <tr>
    <td><a href="../../boost/operators.hpp">boost/operators.hpp</a><br>
      <a href="operators.htm">[Documentation]</a></td>
    <td>Templates <b>equality_comparable</b>, <b>less_than_comparable</b>, <b>addable</b>,
      and the like ease the task of defining comparison and arithmetic
      operators, and iterators.</td>
  </tr>
  <tr>
    <td><a href="../../boost/detail/type_traits.hpp">boost/type_traits.hpp</a><br>
      [<a href="type_traits.htm">Documentation</a>]</td>
    <td>Template classes that describe the fundamental properties of a type. [<a href="c++_type_traits.htm">DDJ
      Article &quot;C++ type traits&quot;</a>]</td>
  </tr>
  <tr>
    <td><a href="../../boost/detail/call_traits.hpp">boost/call_traits.hpp</a><br>
      [<a href="call_traits.htm">Documentation</a>]</td>
    <td>Template class call_traits&lt;T&gt;, that defines types used for passing
      parameters to and from a proceedure.</td>
  </tr>
  <tr>
    <td><a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a><br>
      [<a href="compressed_pair.htm">Documentation</a>]</td>
    <td>Template class compressed_pait&lt;T1, T2&gt; which pairs two values
      using the empty member optimisation where appropriate.</td>
  </tr>
 </table>
 <p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->27 July 2000<!--webbot bot="Timestamp" endspan i-checksum="18770" --></p>
 </body>
 </html>
--- a/index.html
+++ b/index.html
@ -0,0 +1,42 @@
 <html>
 	<head>
 		<meta http-equiv="Content-Language" content="en-us">
 		<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
 		<meta name="ProgId" content="FrontPage.Editor.Document">
 		<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 		<title>Boost Utility Library</title>
 	</head>
 	<body bgcolor="#FFFFFF">
 		<h1><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86" align="center">Boost 
 			Utility Library</h1>
 		<p>The Boost Utility Library isn't really a single library at all. It is just a 
 			collection for components too small to be called libraries in their own right.</p>
 		<p>But that doesn't mean there isn't useful stuff here. Take a look:</p>
 		<blockquote>
 			<p>
 				<a href="assert.html">assert</a><br>
 				<a href="base_from_member.html">base_from_member</a><br>
 				<a href="call_traits.htm">call_traits</a><br>
 				<a href="checked_delete.html">checked_delete</a><br>
 				<a href="compressed_pair.htm">compressed_pair</a><br>
 				<a href="current_function.html">current_function</a><br>
 				<a href="enable_if.html">enable_if</a><br>
            <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
            <a href="generator_iterator.htm">generator iterator adaptors</a><br>
 				<a href="operators.htm">operators</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/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/iterator_adaptors.htm
+++ b/iterator_adaptors.htm
@ -0,0 +1,11 @@
 <!-- Copyright David Abrahams 2004. Distributed under the Boost -->
 <!-- Software License, Version 1.0. (See accompanying -->
 <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <html>
 <head>
 <meta http-equiv="refresh" content="0; URL=../iterator/doc/index.html">
 </head>
 <body>
 This documentation moved to <a href="../iterator/doc/index.html">../iterator/doc/index.html</a>.
 </body>
 </html>
--- a/iterators_test.cpp
+++ b/iterators_test.cpp
@ -1,24 +1,36 @@
 //  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.
 //  Revision History
 //  29 May 01 Factored implementation, added comparison tests, use Test Tools
 //            library (Daryle Walker)
 //  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
-#include <string>
+#define  BOOST_INCLUDE_MAIN
-#include <iostream>
+#include <boost/test/test_tools.hpp>  // for main
 using namespace std;
-#include <boost/operators.hpp>
+#include <boost/config.hpp>     // for BOOST_STATIC_CONSTANT
-using namespace boost;
+#include <boost/cstdlib.hpp>    // for boost::exit_success
 #include <boost/operators.hpp>  // for boost::random_access_iterator_helper
 #include <cstddef>    // for std::ptrdiff_t, std::size_t
 #include <cstring>    // for std::strcmp
 #include <iostream>   // for std::cout (std::endl, ends, and flush indirectly)
 #include <string>     // for std::string
 #include <sstream>    // for std::stringstream
 # ifdef BOOST_NO_STDC_NAMESPACE
    namespace std { using ::strcmp; }
 # endif
 // Iterator test class
 template <class T, class R, class P>
 struct test_iter
  : public boost::random_access_iterator_helper<
@ -29,7 +41,7 @@ struct test_iter
  typedef std::ptrdiff_t Distance;
 public:
-  test_iter(T* i) : _i(i) { }
+  explicit test_iter(T* i =0) : _i(i) { }
  test_iter(const self& x) : _i(x._i) { }
  self& operator=(const self& x) { _i = x._i; return *this; }
  Reference operator*() const { return *_i; }
@ -43,127 +55,270 @@ public:
    return x._i - y._i; 
  }
 protected:
-  T* _i;
+  P _i;
 };
-
+// Iterator operator testing classes
-int
+class test_opr_base
 main()
 {
-  string array[] = { "apple", "orange", "pear", "peach", "grape", "plum"  };
+protected:
-  {
+    // Test data and types
-    test_iter<string,string&,string*> i = array, 
+    BOOST_STATIC_CONSTANT( std::size_t, fruit_length = 6u );
      ie = array + sizeof(array)/sizeof(string);
-    // Tests for all of the operators added by random_access_iterator_helper
+    typedef std::string  fruit_array_type[ fruit_length ];
-    // test i++
+    static  fruit_array_type    fruit;
    while (i != ie)
      cout << *i++ << " ";
    cout << endl;
    i = array;
-    // test i--
+};  // test_opr_base
    while (ie != i) {
      ie--;
      cout << *ie << " ";
    }
    cout << endl;
    ie = array + sizeof(array)/sizeof(string);
-    // test i->m
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-    while (i != ie) {
+//  A definition is required even for integral static constants
-      cout << i->size() << " ";
+const std::size_t test_opr_base::fruit_length;
-      ++i;
+#endif
    }
    cout << endl;
    i = array;
-    // test i + n
+template <typename T, typename R = T&, typename P = T*>
-    while (i < ie) {
+class test_opr
-      cout << *i << " ";
+    : public test_opr_base
-      i = i + 2;
+{
-    }
+    typedef test_opr<T, R, P>  self_type;
    cout << endl;
    i = array;
-    // test n + i
+public:
-    while (i < ie) {
+    // Types
-      cout << *i << " ";
+    typedef T  value_type;
-      i = ptrdiff_t(2) + i;
+    typedef R  reference;
-    }
+    typedef P  pointer;
    cout << endl;
    i = array;
-    // test i - n
+    typedef test_iter<T, R, P>  iter_type;
    while (ie > i) {
      ie = ie - 2;
      cout << *ie << " ";
    }
    cout << endl;
    ie = array + sizeof(array)/sizeof(string);
-    // test i[n]
+    // Test controller
-    for (std::size_t j = 0; j < sizeof(array)/sizeof(string); ++j)
+    static  void  master_test( char const name[] );
      cout << i[j] << " ";
    cout << endl;
  }
  {
    test_iter<string, const string&, const string*> i = array, 
      ie = array + sizeof(array)/sizeof(string);
-    // Tests for all of the operators added by random_access_iterator_helper
+private:
    // Test data
    static iter_type const  fruit_begin;
    static iter_type const  fruit_end;
-    // test i++
+    // Test parts
-    while (i != ie)
+    static  void  post_increment_test();
-      cout << *i++ << " ";
+    static  void  post_decrement_test();
-    cout << endl;
+    static  void  indirect_referral_test();
-    i = array;
+    static  void  offset_addition_test();
    static  void  reverse_offset_addition_test();
    static  void  offset_subtraction_test();
    static  void  comparison_test();
    static  void  indexing_test();
-    // test i--
+};  // test_opr
    while (ie != i) {
      ie--;
      cout << *ie << " ";
    }
    cout << endl;
    ie = array + sizeof(array)/sizeof(string);
    // test i->m
    while (i != ie) {
      cout << i->size() << " ";
      ++i;
    }
    cout << endl;
    i = array;
-    // test i + n
+// Class-static data definitions
-    while (i < ie) {
+test_opr_base::fruit_array_type
-      cout << *i << " ";
+ test_opr_base::fruit = { "apple", "orange", "pear", "peach", "grape", "plum" };
      i = i + 2;
    }
    cout << endl;
    i = array;
-    // test n + i
+template <typename T, typename R, typename P>
-    while (i < ie) {
+  typename test_opr<T, R, P>::iter_type const
-      cout << *i << " ";
+ test_opr<T, R, P>::fruit_begin = test_iter<T,R,P>( fruit );
      i = ptrdiff_t(2) + i;
    }
    cout << endl;
    i = array;
-    // test i - n
+template <typename T, typename R, typename P>
-    while (ie > i) {
+typename test_opr<T, R, P>::iter_type const
-      ie = ie - 2;
+ test_opr<T, R, P>::fruit_end = test_iter<T,R,P>( fruit + fruit_length );
      cout << *ie << " ";
    }
    cout << endl;
    ie = array + sizeof(array)/sizeof(string);
-    // test i[n]
+
-    for (std::size_t j = 0; j < sizeof(array)/sizeof(string); ++j)
+// Main testing function
-      cout << i[j] << " ";
+int
-    cout << endl;
+test_main( int , char * [] )
-  }
+{
-  return 0;
+    using std::string;
    typedef test_opr<string, string &, string *>              test1_type;
    typedef test_opr<string, string const &, string const *>  test2_type;
    test1_type::master_test( "non-const string" );
    test2_type::master_test( "const string" );
    return boost::exit_success;
 }
 // Tests for all of the operators added by random_access_iterator_helper
 template <typename T, typename R, typename P>
 void
 test_opr<T, R, P>::master_test
 (
    char const  name[]
 )
 {
    std::cout << "Doing test run for " << name << '.' << std::endl;
    post_increment_test();
    post_decrement_test();
    indirect_referral_test();
    offset_addition_test();
    reverse_offset_addition_test();
    offset_subtraction_test();
    comparison_test();
    indexing_test();
 }
 // Test post-increment
 template <typename T, typename R, typename P>
 void
 test_opr<T, R, P>::post_increment_test
 (
 )
 {
    std::cout << "\tDoing post-increment test." << std::endl;
    std::stringstream oss;
    for ( iter_type i = fruit_begin ; i != fruit_end ; )
    {
        oss << *i++ << ' ';
    }
    BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 }
 // Test post-decrement
 template <typename T, typename R, typename P>
 void
 test_opr<T, R, P>::post_decrement_test
 (
 )
 {
    std::cout << "\tDoing post-decrement test." << std::endl;
    std::stringstream oss;
    for ( iter_type i = fruit_end ; i != fruit_begin ; )
    {
        i--;
        oss << *i << ' ';
    }
    BOOST_CHECK( oss.str() == "plum grape peach pear orange apple ");
 }
 // Test indirect structure referral
 template <typename T, typename R, typename P>
 void
 test_opr<T, R, P>::indirect_referral_test
 (
 )
 {
    std::cout << "\tDoing indirect reference test." << std::endl;
    std::stringstream oss;
    for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
    {
        oss << i->size() << ' ';
    }
    BOOST_CHECK( oss.str() == "5 6 4 5 5 4 ");
 }
 // Test offset addition
 template <typename T, typename R, typename P>
 void
 test_opr<T, R, P>::offset_addition_test
 (
 )
 {
    std::cout << "\tDoing offset addition test." << std::endl;
    std::ptrdiff_t const  two = 2;
    std::stringstream oss;
    for ( iter_type i = fruit_begin ; i != fruit_end ; i = i + two )
    {
        oss << *i << ' ';
    }
    BOOST_CHECK( oss.str() == "apple pear grape ");
 }
 // Test offset addition, in reverse order
 template <typename T, typename R, typename P>
 void
 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::stringstream oss;
    for ( iter_type i = fruit_begin ; i != fruit_end ; i = two + i )
    {
        oss << *i << ' ';
    }
    BOOST_CHECK( oss.str() == "apple pear grape ");
 }
 // Test offset subtraction
 template <typename T, typename R, typename P>
 void
 test_opr<T, R, P>::offset_subtraction_test
 (
 )
 {
    std::cout << "\tDoing offset subtraction test." << std::endl;
    std::ptrdiff_t const  two = 2;
    std::stringstream oss;
    for ( iter_type i = fruit_end ; fruit_begin < i ; )
    {
        i = i - two;
        if ( (fruit_begin < i) || (fruit_begin == i) )
        {
            oss << *i << ' ';
        }
    }
    BOOST_CHECK( oss.str() == "grape pear apple ");
 }
 // Test comparisons
 template <typename T, typename R, typename P>
 void
 test_opr<T, R, P>::comparison_test
 (
 )
 {
    using std::cout;
    using std::ptrdiff_t;
    cout << "\tDoing comparison tests.\n\t\tPass:";
    for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
    {
        ptrdiff_t const  i_offset = i - fruit_begin;
        cout << ' ' << *i << std::flush;
        for ( iter_type j = fruit_begin ; j != fruit_end ; ++j )
        {
            ptrdiff_t const  j_offset = j - fruit_begin;
            BOOST_CHECK( (i != j) == (i_offset != j_offset) );
            BOOST_CHECK( (i > j) == (i_offset > j_offset) );
            BOOST_CHECK( (i <= j) == (i_offset <= j_offset) );
            BOOST_CHECK( (i >= j) == (i_offset >= j_offset) );
        }
    }
    cout << std::endl;
 }
 // Test indexing
 template <typename T, typename R, typename P>
 void
 test_opr<T, R, P>::indexing_test
 (
 )
 {
    std::cout << "\tDoing indexing test." << std::endl;
    std::stringstream oss;
    for ( std::size_t k = 0u ; k < fruit_length ; ++k )
    {
        oss << fruit_begin[ k ] << ' ';
    }
    BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
 }
--- a/noncopyable_test.cpp
+++ b/noncopyable_test.cpp
@ -1,10 +1,8 @@
 //  boost class noncopyable test program  ------------------------------------//
-//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
+//  (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
@ -20,7 +18,7 @@
 namespace
 {
-    class DontTreadOnMe : boost::noncopyable
+    class DontTreadOnMe : private boost::noncopyable
    {
    public:
         DontTreadOnMe() { std::cout << "defanged!" << std::endl; }
@ -35,4 +33,4 @@ int main()
    object1 = object2;
    return 0;
 }   // main
-  
+  
--- a/numeric_traits_test.cpp
+++ b/numeric_traits_test.cpp
@ -0,0 +1,405 @@
 //  (C) Copyright David Abrahams 2001.
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //  See http://www.boost.org for most recent version including documentation.
 //  Revision History
 //  1  Apr 2001 Fixes for ICL; use BOOST_STATIC_CONSTANT
 //  11 Feb 2001 Fixes for Borland (David Abrahams)
 //  23 Jan 2001 Added test for wchar_t (David Abrahams)
 //  23 Jan 2001 Now statically selecting a test for signed numbers to avoid
 //              warnings with fancy compilers. Added commentary and
 //              additional dumping of traits data for tested types (David
 //              Abrahams).
 //  21 Jan 2001 Initial version (David Abrahams)
 #include <boost/detail/numeric_traits.hpp>
 #include <cassert>
 #include <boost/type_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/utility.hpp>
 #include <boost/lexical_cast.hpp>
 #include <climits>
 #include <typeinfo>
 #include <iostream>
 #include <string>
 #ifndef BOOST_NO_LIMITS
 # include <limits>
 #endif
 // =================================================================================
 // template class complement_traits<Number> --
 //
 //    statically computes the max and min for 1s and 2s-complement binary
 //    numbers. This helps on platforms without <limits> support. It also shows
 //    an example of a recursive template that works with MSVC!
 //
 template <unsigned size> struct complement; // forward
 // The template complement, below, does all the real work, using "poor man's
 // partial specialization". We need complement_traits_aux<> so that MSVC doesn't
 // complain about undefined min/max as we're trying to recursively define them. 
 template <class Number, unsigned size>
 struct complement_traits_aux
 {
    BOOST_STATIC_CONSTANT(Number, max = complement<size>::template traits<Number>::max);
    BOOST_STATIC_CONSTANT(Number, min = complement<size>::template traits<Number>::min);
 };
 template <unsigned size>
 struct complement
 {
    template <class Number>
    struct traits
    {
     private:
        // 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
    };
 };
 // Template class complement_base<> -- defines values for min and max for
 // complement<1>, at the deepest level of recursion. Uses "poor man's partial
 // specialization" again.
 template <bool is_signed> struct complement_base;
 template <> struct complement_base<false>
 {
    template <class Number>
    struct values
    {
        BOOST_STATIC_CONSTANT(Number, min = 0);
        BOOST_STATIC_CONSTANT(Number, max = UCHAR_MAX);
    };
 };
 template <> struct complement_base<true>
 {
    template <class Number>
    struct values
    {
        BOOST_STATIC_CONSTANT(Number, min = SCHAR_MIN);
        BOOST_STATIC_CONSTANT(Number, max = SCHAR_MAX);
    };
 };
 // Base specialization of complement, puts an end to the recursion.
 template <>
 struct complement<1>
 {
    template <class Number>
    struct traits
    {
        BOOST_STATIC_CONSTANT(bool, is_signed = boost::detail::is_signed<Number>::value);
        BOOST_STATIC_CONSTANT(Number, min =
                            complement_base<is_signed>::template values<Number>::min);
        BOOST_STATIC_CONSTANT(Number, max =
                            complement_base<is_signed>::template values<Number>::max);
    };
 };
 // Now here's the "pretty" template you're intended to actually use.
 //   complement_traits<Number>::min, complement_traits<Number>::max are the
 //   minimum and maximum values of Number if Number is a built-in integer type.
 template <class Number>
 struct complement_traits
 {
    BOOST_STATIC_CONSTANT(Number, max = (complement_traits_aux<Number, sizeof(Number)>::max));
    BOOST_STATIC_CONSTANT(Number, min = (complement_traits_aux<Number, sizeof(Number)>::min));
 };
 // =================================================================================
 // Support for streaming various numeric types in exactly the format I want. I
 // needed this in addition to all the assertions so that I could see exactly
 // what was going on.
 //
 // Numbers go through a 2-stage conversion process (by default, though, no real
 // conversion).
 //
 template <class T> struct stream_as {
    typedef T t1;
    typedef T t2;
 };
 // char types first get converted to unsigned char, then to unsigned.
 template <> struct stream_as<char> {
    typedef unsigned char t1;
    typedef unsigned t2;
 };
 template <> struct stream_as<unsigned char> {
    typedef unsigned char t1; typedef unsigned t2;
 };
 template <> struct stream_as<signed char>  {
    typedef unsigned char t1; typedef unsigned t2;
 };
 #if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
 // With this library implementation, __int64 and __uint64 get streamed as strings
 template <> struct stream_as<boost::uintmax_t> {
    typedef std::string t1;
    typedef std::string t2;
 };
 template <> struct stream_as<boost::intmax_t>  {
    typedef std::string t1;
    typedef std::string t2;
 };
 #endif
 // Standard promotion process for streaming
 template <class T> struct promote
 {
    static typename stream_as<T>::t1 from(T x) {
        typedef typename stream_as<T>::t1 t1;
        return t1(x);
    }
 };
 #if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
 // On this platform, stream them as long/unsigned long if they fit.
 // Otherwise, write a string.
 template <> struct promote<boost::uintmax_t> {
    std::string static from(const boost::uintmax_t x) {
        if (x > ULONG_MAX)
            return std::string("large unsigned value");
        else
            return boost::lexical_cast<std::string>((unsigned long)x);
    }
 };
 template <> struct promote<boost::intmax_t> {
    std::string static from(const boost::intmax_t x) {
        if (x > boost::intmax_t(ULONG_MAX))
            return std::string("large positive signed value");
        else if (x >= 0)
            return boost::lexical_cast<std::string>((unsigned long)x);
        if (x < boost::intmax_t(LONG_MIN))
            return std::string("large negative signed value");
        else
            return boost::lexical_cast<std::string>((long)x);
    }
 };
 #endif
 // This is the function which converts types to the form I want to stream them in.
 template <class T>
 typename stream_as<T>::t2 stream_number(T x)
 {
    return promote<T>::from(x);
 }
 // =================================================================================
 //
 // Tests for built-in signed and unsigned types
 //
 // Tag types for selecting tests
 struct unsigned_tag {};
 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*)
 {
    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
    BOOST_STATIC_ASSERT(!boost::detail::is_signed<Number>::value);
    BOOST_STATIC_ASSERT(
        (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;
    const Number test_max = (sizeof(Number) < sizeof(boost::intmax_t))
        ? max
        : max / 2 - 1;
    std::cout << std::hex << "(unsigned) min = " << stream_number(min) << ", max = "
              << stream_number(max) << "..." << std::flush;
    std::cout << "difference_type = " << typeid(difference_type).name() << "..."
              << std::flush;
    difference_type d1 = boost::detail::numeric_distance(Number(0), test_max);
    difference_type d2 = boost::detail::numeric_distance(test_max, Number(0));
    std::cout << "0->" << stream_number(test_max) << "==" << std::dec << stream_number(d1) << "; "
              << std::hex << stream_number(test_max) << "->0==" << std::dec << stream_number(d2) << "..." << std::flush;
    assert(d1 == difference_type(test_max));
    assert(d2 == -difference_type(test_max));
 }
 // Tests for signed numbers. The extra default Number parameter works around an
 // MSVC bug.
 struct out_of_range_tag {};
 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*)
 {
    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
    const Number max = complement_traits<Number>::max;
    const Number min = complement_traits<Number>::min;
    difference_type d1 = boost::detail::numeric_distance(min, max);
    difference_type d2 = boost::detail::numeric_distance(max, min);
    std::cout << stream_number(min) << "->" << stream_number(max) << "==";
    std::cout << std::dec << stream_number(d1) << "; ";
    std::cout << std::hex << stream_number(max) << "->" << stream_number(min)
              << "==" << std::dec << stream_number(d2) << "..." << std::flush;
    assert(d1 == difference_type(max) - difference_type(min));
    assert(d2 == difference_type(min) - difference_type(max));
 }
 // 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*)
 {
    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
    const Number max = complement_traits<Number>::max;
    const Number min = complement_traits<Number>::min;
    difference_type min_distance = complement_traits<difference_type>::min;
    difference_type max_distance = complement_traits<difference_type>::max;
    const Number n1 = Number(min + max_distance);
    const Number n2 = Number(max + min_distance);
    difference_type d1 = boost::detail::numeric_distance(min, n1);
    difference_type d2 = boost::detail::numeric_distance(max, n2);
    std::cout << stream_number(min) << "->" << stream_number(n1) << "==";
    std::cout << std::dec << stream_number(d1) << "; ";
    std::cout << std::hex << stream_number(max) << "->" << stream_number(n2)
              << "==" << std::dec << stream_number(d2) << "..." << std::flush;
    assert(d1 == max_distance);
    assert(d2 == min_distance);
 }
 template <class Number>
 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);
    BOOST_STATIC_ASSERT(
        (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;
    std::cout << std::hex << "min = " << stream_number(min) << ", max = "
              << stream_number(max) << "..." << std::flush;
    std::cout << "difference_type = " << typeid(difference_type).name() << "..."
              << std::flush;
    typedef typename boost::detail::if_true<
                          (sizeof(Number) < sizeof(boost::intmax_t))>
                        ::template then<
                          in_range_tag,
                          out_of_range_tag
                        >::type
        range_tag;
    signed_test<Number>(range_tag(), 0);
 }
 // Test for all numbers. The extra default Number parameter works around an MSVC
 // bug.
 template <class Number>
 void test(Number* = 0)
 {
    std::cout << "testing " << typeid(Number).name() << ":\n"
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
              << "is_signed: " << (std::numeric_limits<Number>::is_signed ? "true\n" : "false\n")
              << "is_bounded: " << (std::numeric_limits<Number>::is_bounded ? "true\n" : "false\n")
              << "digits: " << std::numeric_limits<Number>::digits << "\n"
 #endif
              << "..." << std::flush;
    // factoring out difference_type for the assert below confused Borland :(
    typedef boost::detail::is_signed<
 #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
        typename
 #endif
        boost::detail::numeric_traits<Number>::difference_type
        > is_signed;
    BOOST_STATIC_ASSERT(is_signed::value);
    typedef typename boost::detail::if_true<
        boost::detail::is_signed<Number>::value
        >::template then<signed_tag, unsigned_tag>::type signedness;
    test_aux<Number>(signedness(), 0);
    std::cout << "passed" << std::endl;
 }
 int main()
 {
    test<char>();
    test<unsigned char>();
    test<signed char>();
    test<wchar_t>();
    test<short>();
    test<unsigned short>();
    test<int>();
    test<unsigned int>();
    test<long>();
    test<unsigned long>();
 #if defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T)
    test< ::boost::long_long_type>();
    test< ::boost::ulong_long_type>();
 #elif defined(BOOST_MSVC)
    // The problem of not having compile-time static class constants other than
    // enums prevents this from working, since values get truncated.
    // test<boost::uintmax_t>();
    // test<boost::intmax_t>();
 #endif
    return 0;
 }
--- a/operators.htm
+++ b/operators.htm
--- a/operators_test.cpp
+++ b/operators_test.cpp
--- a/ref_ct_test.cpp
+++ b/ref_ct_test.cpp
@ -0,0 +1,134 @@
 // Copyright David Abrahams and Aleksey Gurtovoy
 // 2002-2004. Distributed under the Boost Software License, Version
 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // compile-time test for "boost/ref.hpp" header content
 // see 'ref_test.cpp' for run-time part
 #include <boost/ref.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/mpl/assert.hpp>
 namespace {
 template< typename T, typename U >
 void ref_test(boost::reference_wrapper<U>)
 {
    typedef typename boost::reference_wrapper<U>::type type;
    BOOST_STATIC_ASSERT((boost::is_same<U,type>::value));
    BOOST_STATIC_ASSERT((boost::is_same<T,type>::value));
 }
 template< typename T >
 void assignable_test(T x)
 {
    x = x;
 }
 template< bool R, typename T >
 void is_reference_wrapper_test(T)
 {
    BOOST_STATIC_ASSERT(boost::is_reference_wrapper<T>::value == R);
 }
 template< typename R, typename Ref >
 void cxx_reference_test(Ref)
 {
 #if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
    typedef typename boost::remove_const<Ref>::type ref;
    BOOST_STATIC_ASSERT((boost::is_same<R,ref>::value));
 #else
    BOOST_STATIC_ASSERT((boost::is_same<R,Ref>::value));
 #endif
 }
 template< typename R, typename Ref >
 void unwrap_reference_test(Ref)
 {
 #if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
    typedef typename boost::remove_const<Ref>::type ref;
    typedef typename boost::unwrap_reference<ref>::type type;
 #else
    typedef typename boost::unwrap_reference<Ref>::type type;
 #endif
    BOOST_STATIC_ASSERT((boost::is_same<R,type>::value));
 }
 } // namespace
 int main()
 {
    int i = 0;
    int& ri = i;
    int const ci = 0;
    int const& rci = ci;
    // 'ref/cref' functions test
    ref_test<int>(boost::ref(i));
    ref_test<int>(boost::ref(ri));
    ref_test<int const>(boost::ref(ci));
    ref_test<int const>(boost::ref(rci));
    ref_test<int const>(boost::cref(i));
    ref_test<int const>(boost::cref(ri));
    ref_test<int const>(boost::cref(ci));
    ref_test<int const>(boost::cref(rci));
    // test 'assignable' requirement
    assignable_test(boost::ref(i));
    assignable_test(boost::ref(ri));
    assignable_test(boost::cref(i));
    assignable_test(boost::cref(ci));
    assignable_test(boost::cref(rci));
    // 'is_reference_wrapper' test
    is_reference_wrapper_test<true>(boost::ref(i));
    is_reference_wrapper_test<true>(boost::ref(ri));
    is_reference_wrapper_test<true>(boost::cref(i));
    is_reference_wrapper_test<true>(boost::cref(ci));
    is_reference_wrapper_test<true>(boost::cref(rci));
    is_reference_wrapper_test<false>(i);
    is_reference_wrapper_test<false, int&>(ri);
    is_reference_wrapper_test<false>(ci);
    is_reference_wrapper_test<false, int const&>(rci);
    // ordinary references/function template arguments deduction test
    cxx_reference_test<int>(i);
    cxx_reference_test<int>(ri);
    cxx_reference_test<int>(ci);
    cxx_reference_test<int>(rci);
    cxx_reference_test<int&, int&>(i);
    cxx_reference_test<int&, int&>(ri);
    cxx_reference_test<int const&, int const&>(i);
    cxx_reference_test<int const&, int const&>(ri);
    cxx_reference_test<int const&, int const&>(ci);
    cxx_reference_test<int const&, int const&>(rci);
    // 'unwrap_reference' test
    unwrap_reference_test<int>(boost::ref(i));
    unwrap_reference_test<int>(boost::ref(ri));
    unwrap_reference_test<int const>(boost::cref(i));
    unwrap_reference_test<int const>(boost::cref(ci));
    unwrap_reference_test<int const>(boost::cref(rci));
    unwrap_reference_test<int>(i);
    unwrap_reference_test<int>(ri);
    unwrap_reference_test<int>(ci);
    unwrap_reference_test<int>(rci);
    unwrap_reference_test<int&, int&>(i);
    unwrap_reference_test<int&, int&>(ri);
    unwrap_reference_test<int const&, int const&>(i);
    unwrap_reference_test<int const&, int const&>(ri);
    unwrap_reference_test<int const&, int const&>(ci);
    unwrap_reference_test<int const&, int const&>(rci);
    return 0;
 }
--- a/ref_test.cpp
+++ b/ref_test.cpp
@ -0,0 +1,121 @@
 // Copyright David Abrahams and Aleksey Gurtovoy
 // 2002-2004. Distributed under the Boost Software License, Version
 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // run-time test for "boost/ref.hpp" header content
 // see 'ref_ct_test.cpp' for compile-time part
 #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
 #include <boost/ref.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
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 namespace {
 using namespace boost;
 template <class T>
 struct ref_wrapper
 {
    // Used to verify implicit conversion
    static T* get_pointer(T& x)
    {
        return &x;
    }
    static T const* get_const_pointer(T const& x)
    {
        return &x;
    }
    template <class Arg>
    static T* passthru(Arg x)
    {
        return get_pointer(x);
    }
    template <class Arg>
    static T const* cref_passthru(Arg x)
    {
        return get_const_pointer(x);
    }
    static void test(T x)
    {
        BOOST_CHECK(passthru(ref(x)) == &x);
        BOOST_CHECK(&ref(x).get() == &x);
        BOOST_CHECK(cref_passthru(cref(x)) == &x);
        BOOST_CHECK(&cref(x).get() == &x);
    }
 };
 struct copy_counter {
  static int count_;
  copy_counter(copy_counter const& /*other*/) {
    ++count_;
  }
  copy_counter() {}
  static void reset() { count_ = 0; }
  static int count() { return copy_counter::count_;  }
 };
 int copy_counter::count_ = 0;
 } // namespace unnamed
 template <class T>
 void do_unwrap(T t) {
  /* typename unwrap_reference<T>::type& lt = */
  unwrap_ref(t);
 }
 void unwrap_test() {
  int i = 3;
  const int ci = 2;
  do_unwrap(i);
  do_unwrap(ci);
  do_unwrap(ref(i));
  do_unwrap(cref(ci));
  do_unwrap(ref(ci));
  copy_counter cc;
  BOOST_CHECK(cc.count() == 0);
  do_unwrap(cc);
  do_unwrap(ref(cc));
  do_unwrap(cref(cc));
  BOOST_CHECK(cc.count() == 1);
  BOOST_CHECK(unwrap_ref(ref(cc)).count() == 1); 
 }
 int test_main(int, char * [])
 {
    ref_wrapper<int>::test(1);
    ref_wrapper<int const>::test(1);
    unwrap_test();
    return 0;
 }
--- a/shared_container_iterator.html
+++ b/shared_container_iterator.html
@ -0,0 +1,322 @@
 <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>Shared Container Iterator Documentation</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <img src="../../boost.png" alt="boost.png (6897 bytes)"
 align="center" width="277" height="86">
 <h1>Shared Container Iterator</h1>
 Defined in header
 <a href="../../boost/shared_container_iterator.hpp">boost/shared_container_iterator.hpp</a>
 <p>
 The purpose of the shared container iterator is to attach the lifetime
 of a container to the lifetime of its iterators. In other words, the
 container will not be deleted until after all its iterators are
 destroyed.  The shared container iterator is typically used to
 implement functions that return iterators over a range of objects that
 only need to exist for the lifetime of the iterators.  By returning a
 pair of shared iterators from a function, the callee can return a
 heap-allocated range of objects whose lifetime is automatically managed.
 <p>
 The shared container iterator augments an iterator over a shared
 container.  It maintains a reference count on the shared 
 container. If only shared container iterators hold references to
 the container, the container's lifetime will end when the last shared
 container iterator over it is destroyed.  In any case, the shared
 container is guaranteed to persist beyond the lifetime of all
 the iterators. In all other ways, the
 shared container iterator behaves the same as its base iterator.
 <h2>Synopsis</h2>
 <pre>
 namespace boost {
  template &lt;typename <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>&gt;
  class shared_container_iterator;
  template &lt;typename <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>&gt;
  shared_container_iterator&lt;Container&gt;
  make_shared_container_iterator(typename Container::iterator base, 
    boost::shared_ptr&lt;Container&gt; const&amp; container);
  std::pair&lt;
    typename shared_container_iterator&lt;Container&gt;,
    typename shared_container_iterator&lt;Container&gt;
  &gt;
  make_shared_container_range(boost::shared_ptr&lt;Container&gt; const&amp; container);
 }
 </pre>
 <hr>
 <h2><a name="generator">The Shared Container Iterator Type</a></h2>
 <pre>
 template &lt;typename Container&gt; class shared_container_iterator;
 </pre>
 The class template <tt>shared_container_iterator</tt> 
 is the shared container iterator type.  The <tt>Container</tt> template
 type argument must model the
 <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>
 concept.
 <h3>Example</h3>
 <p>
 The following example illustrates how to create an iterator that 
 regulates the lifetime of a reference counted <tt>std::vector</tt>.
 Though the original shared pointer <tt>ints</tt> ceases to exist
 after <tt>set_range()</tt> returns, the
 <tt>shared_counter_iterator</tt> objects maintain references to the
      underlying vector and thereby extend the container's lifetime.
 <p>
 <a href="./shared_iterator_example1.cpp">shared_iterator_example1.cpp</a>:
 <PRE>
 <font color="#008040">#include "shared_container_iterator.hpp"</font>
 <font color="#008040">#include "boost/shared_ptr.hpp"</font>
 <font color="#008040">#include &lt;algorithm&gt;</font>
 <font color="#008040">#include &lt;iostream&gt;</font>
 <font color="#008040">#include &lt;vector&gt;</font>
 <B>typedef</B> boost::shared_container_iterator&lt; std::vector&lt;<B>int</B>&gt; &gt; iterator;
 <B>void</B> set_range(iterator& i, iterator& end)  {
  boost::shared_ptr&lt; std::vector&lt;<B>int</B>&gt; &gt; ints(<B>new</B> std::vector&lt;<B>int</B>&gt;());
  ints-&gt;push_back(<font color="#0000A0">0</font>);
  ints-&gt;push_back(<font color="#0000A0">1</font>);
  ints-&gt;push_back(<font color="#0000A0">2</font>);
  ints-&gt;push_back(<font color="#0000A0">3</font>);
  ints-&gt;push_back(<font color="#0000A0">4</font>);
  ints-&gt;push_back(<font color="#0000A0">5</font>);
  i = iterator(ints-&gt;begin(),ints);
  end = iterator(ints-&gt;end(),ints);
 }
 <B>int</B> main() {
  iterator i,end;
  set_range(i,end);
  std::copy(i,end,std::ostream_iterator&lt;<B>int</B>&gt;(std::cout,<font color="#0000FF">","</font>));
  std::cout.put(<font color="#0000FF">'\n'</font>);
  <B>return</B> <font color="#0000A0">0</font>;
 }
 </PRE>
 The output from this part is:
 <pre>
 0,1,2,3,4,5,
 </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/Container.html"><tt>Container</tt></a></TD>
 <TD>The type of the container that we wish to iterate over. It must be 
 a model of the 
 <a href="http://www.sgi.com/tech/stl/Container.html"><tt>Container</tt></a>
 concept.
 </TD>
 </TR>
 </Table>
 <h3>Model of</h3>
 The <tt>shared_container_iterator<Container></tt> type models the
 same iterator concept as the base iterator
    (<tt>Container::iterator</tt>).
 <h3>Members</h3>
 The shared container 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, though only operations defined for the base iterator will be valid.
 In addition it has the following constructor:
 <pre>
 shared_container_iterator(Container::iterator const&amp; it,
                          boost::shared_ptr&lt;Container&gt; const&amp; container)
 </pre>
 <p>
 <hr>
 <p>
 <h2><a name="make_iterator">The Shared Container Iterator Object Generator</a></h2>
 <pre>
 template &lt;typename Container&gt;
 shared_container_iterator&lt;Container&gt;
 make_shared_container_iterator(Container::iterator base,
                               boost::shared_ptr&lt;Container&gt; const&amp; container)
 </pre>
 This function provides an alternative to directly constructing a
 shared container iterator.  Using the object generator, a shared
 container iterator can be created and passed to a function without
 explicitly specifying its type.
 <h3>Example</h3>
 This example, similar to the previous, uses 
 <tt>make_shared_container_iterator()</tt> to create the iterators.
 <p>
 <a href="./shared_iterator_example2.cpp">shared_iterator_example2.cpp</a>:
 <PRE>
 <font color="#008040">#include "shared_container_iterator.hpp"</font>
 <font color="#008040">#include "boost/shared_ptr.hpp"</font>
 <font color="#008040">#include &lt;algorithm&gt;</font>
 <font color="#008040">#include &lt;iterator&gt;</font>
 <font color="#008040">#include &lt;iostream&gt;</font>
 <font color="#008040">#include &lt;vector&gt;</font>
 <B>template</B> &lt;<B>typename</B> Iterator&gt;
 <B>void</B> print_range_nl (Iterator begin, Iterator end) {
  <B>typedef</B> <B>typename</B> std::iterator_traits&lt;Iterator&gt;::value_type val;
  std::copy(begin,end,std::ostream_iterator&lt;val&gt;(std::cout,<font color="#0000FF">","</font>));
  std::cout.put(<font color="#0000FF">'\n'</font>);
 }
 <B>int</B> main() {
  <B>typedef</B> boost::shared_ptr&lt; std::vector&lt;<B>int</B>&gt; &gt; ints_t;
  {
    ints_t ints(<B>new</B> std::vector&lt;<B>int</B>&gt;());
    ints-&gt;push_back(<font color="#0000A0">0</font>);
    ints-&gt;push_back(<font color="#0000A0">1</font>);
    ints-&gt;push_back(<font color="#0000A0">2</font>);
    ints-&gt;push_back(<font color="#0000A0">3</font>);
    ints-&gt;push_back(<font color="#0000A0">4</font>);
    ints-&gt;push_back(<font color="#0000A0">5</font>);
    print_range_nl(boost::make_shared_container_iterator(ints-&gt;begin(),ints),
 		   boost::make_shared_container_iterator(ints-&gt;end(),ints));
  }
  <B>return</B> <font color="#0000A0">0</font>;
 }
 </PRE>
 Observe that the <tt>shared_container_iterator</tt> type is never
 explicitly named. The output from this example is the same as the previous.
 <h2><a name="make_range">The Shared Container Iterator Range Generator</a></h2>
 <pre>
 template &lt;typename Container&gt;
 std::pair&lt
  shared_container_iterator&lt;Container&gt;,
  shared_container_iterator&lt;Container&gt;
 &gt;
 make_shared_container_range(boost::shared_ptr&lt;Container&gt; const&amp; container);
 </pre>
 Class <tt>shared_container_iterator</tt> is meant primarily to return,
 using iterators, a range of values that we can guarantee will be alive as 
 long as the iterators are. This is a convenience
 function to do just that. It is equivalent to
 <pre>
 std::make_pair(make_shared_container_iterator(container-&gt;begin(),container),
               make_shared_container_iterator(container-&gt;end(),container));
 </pre>
 <h3>Example</h3>
 In the following example, a range of values is returned as a pair of
 <tt>shared_container_iterator</tt> objects.  
 <p>
 <a href="./shared_iterator_example3.cpp">shared_iterator_example3.cpp</a>:
 <PRE>
 <font color="#008040">#include "shared_container_iterator.hpp"</font>
 <font color="#008040">#include "boost/shared_ptr.hpp"</font>
 <font color="#008040">#include "boost/tuple/tuple.hpp" // for boost::tie</font>
 <font color="#008040">#include &lt;algorithm&gt;              // for std::copy</font>
 <font color="#008040">#include &lt;iostream&gt;              </font>
 <font color="#008040">#include &lt;vector&gt;</font>
 <B>typedef</B> boost::shared_container_iterator&lt; std::vector&lt;<B>int</B>&gt; &gt; iterator; 
 std::pair&lt;iterator,iterator&gt;
 return_range() {
  boost::shared_ptr&lt; std::vector&lt;<B>int</B>&gt; &gt; range(<B>new</B> std::vector&lt;<B>int</B>&gt;());
  range-&gt;push_back(<font color="#0000A0">0</font>);
  range-&gt;push_back(<font color="#0000A0">1</font>);
  range-&gt;push_back(<font color="#0000A0">2</font>);
  range-&gt;push_back(<font color="#0000A0">3</font>);
  range-&gt;push_back(<font color="#0000A0">4</font>);
  range-&gt;push_back(<font color="#0000A0">5</font>);
  <B>return</B> boost::make_shared_container_range(range);
 }
 <B>int</B> main() {
  iterator i,end;
  boost::tie(i,end) = return_range();
  std::copy(i,end,std::ostream_iterator&lt;<B>int</B>&gt;(std::cout,<font color="#0000FF">","</font>));
  std::cout.put(<font color="#0000FF">'\n'</font>);
  <B>return</B> <font color="#0000A0">0</font>;
 }
 </PRE>
 Though the <tt>range</tt> object only lives for the duration of the
 <tt>return_range</tt> call, the reference counted
 <tt>std::vector</tt> will live until <tt>i</tt> and <tt>end</tt>
 are both destroyed.  The output from this example is the same as
 the previous two.
 <hr>
 <!-- hhmts start -->
 Last modified: Mon Aug 11 11:27:03 EST 2003
 <!-- hhmts end -->
 <p><EFBFBD> Copyright 2003 The Trustees of Indiana University.
 Use, modification and distribution is subject to the Boost Software 
 License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt)</p>
 </body>
 </html>
--- a/shared_iterator_example1.cpp
+++ b/shared_iterator_example1.cpp
@ -0,0 +1,42 @@
 // Copyright 2003 The Trustees of Indiana University.
 // Use, modification and distribution is subject to the Boost Software 
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #include "boost/shared_container_iterator.hpp"
 #include "boost/shared_ptr.hpp"
 #include <algorithm>
 #include <iostream>
 #include <vector>
 typedef boost::shared_container_iterator< std::vector<int> > iterator;
 void set_range(iterator& i, iterator& end)  {
  boost::shared_ptr< std::vector<int> > ints(new std::vector<int>());
  ints->push_back(0);
  ints->push_back(1);
  ints->push_back(2);
  ints->push_back(3);
  ints->push_back(4);
  ints->push_back(5);
  i = iterator(ints->begin(),ints);
  end = iterator(ints->end(),ints);
 }
 int main() {
  iterator i,end;
  set_range(i,end);
  std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
  std::cout.put('\n');
  return 0;
 }
--- a/shared_iterator_example2.cpp
+++ b/shared_iterator_example2.cpp
@ -0,0 +1,43 @@
 // Copyright 2003 The Trustees of Indiana University.
 // Use, modification and distribution is subject to the Boost Software 
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #include "boost/shared_container_iterator.hpp"
 #include "boost/shared_ptr.hpp"
 #include <algorithm>
 #include <iterator>
 #include <iostream>
 #include <vector>
 template <typename Iterator>
 void print_range_nl (Iterator begin, Iterator end) {
  typedef typename std::iterator_traits<Iterator>::value_type val;
  std::copy(begin,end,std::ostream_iterator<val>(std::cout,","));
  std::cout.put('\n');
 }
 int main() {
  typedef boost::shared_ptr< std::vector<int> > ints_t;
  {
    ints_t ints(new std::vector<int>());
    ints->push_back(0);
    ints->push_back(1);
    ints->push_back(2);
    ints->push_back(3);
    ints->push_back(4);
    ints->push_back(5);
    print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
                   boost::make_shared_container_iterator(ints->end(),ints));
  }
  return 0;
 }
--- a/shared_iterator_example3.cpp
+++ b/shared_iterator_example3.cpp
@ -0,0 +1,41 @@
 // Copyright 2003 The Trustees of Indiana University.
 // Use, modification and distribution is subject to the Boost Software 
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #include "boost/shared_container_iterator.hpp"
 #include "boost/shared_ptr.hpp"
 #include "boost/tuple/tuple.hpp" // for boost::tie
 #include <algorithm>              // for std::copy
 #include <iostream>              
 #include <vector>
 typedef boost::shared_container_iterator< std::vector<int> > iterator;
 std::pair<iterator,iterator>
 return_range() {
  boost::shared_ptr< std::vector<int> > range(new std::vector<int>());
  range->push_back(0);
  range->push_back(1);
  range->push_back(2);
  range->push_back(3);
  range->push_back(4);
  range->push_back(5);
  return boost::make_shared_container_range(range);
 }
 int main() {
  iterator i,end;
  boost::tie(i,end) = return_range();
  std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
  std::cout.put('\n');
  return 0;
 }
--- a/shared_iterator_test.cpp
+++ b/shared_iterator_test.cpp
@ -0,0 +1,64 @@
 // Copyright 2003 The Trustees of Indiana University.
 // Use, modification and distribution is subject to the Boost Software 
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //  Shared container iterator adaptor 
 //  Author: Ronald Garcia
 //  See http://boost.org/libs/utility/shared_container_iterator.html 
 //  for documentation. 
 //
 // shared_iterator_test.cpp - Regression tests for shared_container_iterator.
 //
 #include "boost/shared_container_iterator.hpp"
 #include "boost/shared_ptr.hpp"
 #include <vector>
 #include <cassert>
 struct resource {
  static int count;
  resource() { ++count; }
  resource(resource const&) { ++count; }
  ~resource() { --count; }
 };
 int resource::count = 0;
 typedef std::vector<resource> resources_t;
 typedef boost::shared_container_iterator< resources_t > iterator;
 void set_range(iterator& i, iterator& end)  {
  boost::shared_ptr< resources_t > objs(new resources_t());
  for (int j = 0; j != 6; ++j)
    objs->push_back(resource());
  i = iterator(objs->begin(),objs);
  end = iterator(objs->end(),objs);
  assert(resource::count == 6);
 }
 int main() {
  assert(resource::count == 0);
  {
    iterator i;
    {
      iterator end;
      set_range(i,end);
      assert(resource::count == 6);
    }
    assert(resource::count == 6);
  }
  assert(resource::count == 0);
  return 0;
 }
--- a/1
+++ b/1
@ -0,0 +1 @@
 The existance of this file tells the regression reporting programs that the directory contains sub-directories which are libraries.
--- a/swap.html
+++ b/swap.html
@ -0,0 +1,98 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>Boost: Swap Documentation</title>
   </head>
  <body>
    <!-- Page header -->
    <h2>
    <img src="../../boost.png" alt="C++ Boost" align="middle" width="277" height="86"/>
      Header &lt;<a href="../../boost/swap.hpp">boost/swap.hpp</a>&gt;
    </h2>
    <h1>Swap</h1>
    <p>
      <tt>template&lt;class T&gt; void swap(T&amp; <em>left</em>, T&amp; <em>right</em>);</tt>
    </p>
    <!-- Introduction -->
    <p>
      The template function <tt>boost::swap</tt> allows the values of two variables to be swapped, using argument dependent lookup to select a specialized swap function if available. If no specialized swap function is available, <tt>std::swap</tt> is used.
    </p>
    <!-- Rationale -->
    <h2>Rationale</h2>
    <p>
      The generic <tt>std::swap</tt> function requires that the elements to be swapped are assignable and copy constructible. It is usually implemented using one copy construction and two assignments - this is often both unnecessarily restrictive and unnecessarily slow. In addition, where the generic swap implementation provides only the basic guarantee, specialized swap functions are often able to provide the no-throw exception guarantee (and it is considered best practice to do so where possible<sup><a href="#ref1">1</a></sup>).</p>
    <p>
      The alternative to using argument dependent lookup in this situation is to provide a template specialization of <tt>std::swap</tt> for every type that requires a specialized swap. Although this is legal C++, no Boost libraries use this method, whereas many Boost libraries provide specialized swap functions in their own namespaces.
    </p>
    <p>
      <tt>boost::swap</tt> also supports swapping built-in arrays. Note that <tt>std::swap</tt> originally did not do so, but a request to add an overload of <tt>std::swap</tt> for built-in arrays has been accepted by the C++ Standards Committee<sup><a href="#ref2">2</a></sup>.
    </p>
    <!-- Exception Safety -->
    <h2>Exception Safety</h2>
    <p>
      <tt>boost::swap</tt> provides the same exception guarantee as the underlying swap function used, with one exception; for an array of type <tt>T[n]</tt>, where <tt>n > 1</tt> and the underlying swap function for <tt>T</tt> provides the strong exception guarantee, <tt>boost::swap</tt> provides only the basic exception guarantee.
    </p>
    <!-- Requirements -->
    <h2>Requirements</h2>
    <p>Either:</p>
    <ul>      
      <li>T must be assignable</li>
      <li>T must be copy constructible</li>
    </ul>
    <p>Or:</p>
    <ul>
      <li>A function with the signature <tt>swap(T&amp;,T&amp;)</tt> is available via argument dependent lookup</li>
    </ul>
    <p>Or:</p>
    <ul>
      <li>A template specialization of <tt>std::swap</tt> exists for T</li>
    </ul>
    <p>Or:</p>
    <ul>
      <li>T is a built-in array of swappable elements</li>
    </ul>
    <!-- Portability -->
    <h2>Portability</h2>
    <p>
      Several older compilers do not support argument dependent lookup &#x2012; on these compilers <tt>boost::swap</tt> will call <tt>std::swap</tt>, ignoring any specialized swap functions that could be found as a result of argument dependent lookup.
    </p>
    <!-- Credits -->
    <h2>Credits</h2>
    <ul>
      <li>
        <em>Niels Dekker</em> - for implementing and documenting support for built-in arrays
      </li>
      <li>
        <em><a href="mailto:Joseph.Gauterin@googlemail.com">Joseph Gauterin</a></em> - for the initial idea, implementation, tests, and documentation
      </li>
      <li>
        <em>Steven Watanabe</em> - for the idea to make <tt>boost::swap</tt> less specialized than <tt>std::swap</tt>, thereby allowing the function to have the name 'swap' without introducing ambiguity
      </li>      
    </ul>
    <!-- References -->
    <hr/>
    <p><sup><a id="ref1"/>[1]</sup>Scott Meyers, Effective C++ Third Edition, Item 25: "Consider support for a non-throwing swap"</p>
    <p><sup><a id="ref2"/>[2]</sup><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">LWG Defect Report 809 (std::swap should be overloaded for array types)</a></p>
    <!-- Copyright info -->    
    <hr/>
    <p>Revised: 08 September 2009</p>
    <p>
      Copyright 2007 - 2009 Joseph Gauterin. Use, modification, and distribution are subject to the Boost Software License, Version 1.0.
      (See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)
    </p>
  </body>
 </html>
--- a/swap/test/Jamfile.v2
+++ b/swap/test/Jamfile.v2
@ -0,0 +1,37 @@
 # Copyright (c) 2007, 2008 Joseph Gauterin
 #
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at
 # http://www.boost.org/LICENSE_1_0.txt)
 # bring in rules for testing
 import testing ;
 test-suite utility/swap
    :
    [ compile root_header_1.cpp                                  ]
    [ compile root_header_2.cpp                                  ]
    [ compile lib_header_1.cpp                                   ]
    [ compile lib_header_2.cpp                                   ]
    [ compile mixed_headers_1.cpp                                ]
    [ compile mixed_headers_2.cpp                                ]
    [ run primitive.cpp ../../../test/build//boost_test_exec_monitor/<link>static                      ]
    [ run specialized_in_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static           ]
    [ run specialized_in_global.cpp ../../../test/build//boost_test_exec_monitor/<link>static          ]
    [ run specialized_in_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static           ]
    [ run specialized_in_std.cpp ../../../test/build//boost_test_exec_monitor/<link>static             ]
    [ run specialized_in_boost_and_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static ]
    [ run std_bitset.cpp ../../../test/build//boost_test_exec_monitor/<link>static                     ]
    [ run std_dateorder.cpp ../../../test/build//boost_test_exec_monitor/<link>static                  ]
    [ run std_string.cpp ../../../test/build//boost_test_exec_monitor/<link>static                     ]
    [ run std_typeinfo_ptr.cpp ../../../test/build//boost_test_exec_monitor/<link>static               ]
    [ run std_vector_of_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static            ]
    [ run std_vector_of_global.cpp ../../../test/build//boost_test_exec_monitor/<link>static           ]
    [ run std_vector_of_other.cpp ../../../test/build//boost_test_exec_monitor/<link>static            ]
    [ run no_ambiguity_in_boost.cpp ../../../test/build//boost_test_exec_monitor/<link>static          ]
    [ run array_of_array_of_class.cpp ../../../test/build//boost_test_exec_monitor/<link>static        ]
    [ run array_of_array_of_int.cpp ../../../test/build//boost_test_exec_monitor/<link>static          ]
    [ run array_of_class.cpp ../../../test/build//boost_test_exec_monitor/<link>static                 ]
    [ run array_of_int.cpp ../../../test/build//boost_test_exec_monitor/<link>static                   ]
    [ run array_of_template.cpp ../../../test/build//boost_test_exec_monitor/<link>static              ]
    ;
--- a/swap/test/array_of_array_of_class.cpp
+++ b/swap/test/array_of_array_of_class.cpp
@ -0,0 +1,69 @@
 // Copyright (c) 2008 Joseph Gauterin, Niels Dekker
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
 #include <boost/utility/swap.hpp>
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 //Put test class in the global namespace
 #include "./swap_test_class.hpp"
 #include <algorithm> //for std::copy and std::equal
 #include <cstddef> //for std::size_t
 //Provide swap function in both the namespace of swap_test_class
 //(which is the global namespace), and the std namespace.
 //It's common to provide a swap function for a class in both
 //namespaces. Scott Meyers recommends doing so: Effective C++,
 //Third Edition, item 25, "Consider support for a non-throwing swap".
 void swap(swap_test_class& left, swap_test_class& right)
 {
  left.swap(right);
 }
 namespace std
 {
  template <>
  void swap(swap_test_class& left, swap_test_class& right)
  {
    left.swap(right);
  }
 }
 int test_main(int, char*[])
 {
  const std::size_t first_dimension = 3;
  const std::size_t second_dimension = 4;
  const std::size_t number_of_elements = first_dimension * second_dimension;
  swap_test_class array1[first_dimension][second_dimension];
  swap_test_class array2[first_dimension][second_dimension];
  swap_test_class* const ptr1 = array1[0];
  swap_test_class* const ptr2 = array2[0];
  for (std::size_t i = 0; i < number_of_elements; ++i)
  {
    ptr1[i].set_data( static_cast<int>(i) );
    ptr2[i].set_data( static_cast<int>(i + number_of_elements) );
  }
  boost::swap(array1, array2);
  for (std::size_t i = 0; i < number_of_elements; ++i)
  {
    BOOST_CHECK_EQUAL(ptr1[i].get_data(), static_cast<int>(i + number_of_elements) );
    BOOST_CHECK_EQUAL(ptr2[i].get_data(), static_cast<int>(i) );
  }
  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), number_of_elements);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
  return 0;
 }
--- a/swap/test/array_of_array_of_int.cpp
+++ b/swap/test/array_of_array_of_int.cpp
@ -0,0 +1,42 @@
 // Copyright (c) 2008 Joseph Gauterin, Niels Dekker
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // Tests swapping an array of arrays of integers by means of boost::swap.
 #include <boost/utility/swap.hpp>
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 #include <algorithm> //for std::copy and std::equal
 #include <cstddef> //for std::size_t
 int test_main(int, char*[])
 {
  const std::size_t first_dimension = 3;
  const std::size_t second_dimension = 4;
  const std::size_t number_of_elements = first_dimension * second_dimension;
  int array1[first_dimension][second_dimension];
  int array2[first_dimension][second_dimension];
  int* const ptr1 = array1[0];
  int* const ptr2 = array2[0];
  for (std::size_t i = 0; i < number_of_elements; ++i)
  {
    ptr1[i] = static_cast<int>(i);
    ptr2[i] = static_cast<int>(i + number_of_elements);
  }
  boost::swap(array1, array2);
  for (std::size_t i = 0; i < number_of_elements; ++i)
  {
    BOOST_CHECK_EQUAL(ptr1[i], static_cast<int>(i + number_of_elements) );
    BOOST_CHECK_EQUAL(ptr2[i], static_cast<int>(i) );
  }
  return 0;
 }
--- a/swap/test/array_of_class.cpp
+++ b/swap/test/array_of_class.cpp
@ -0,0 +1,61 @@
 // Copyright (c) 2008 Joseph Gauterin, Niels Dekker
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
 #include <boost/utility/swap.hpp>
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 //Put test class in the global namespace
 #include "./swap_test_class.hpp"
 #include <algorithm> //for std::copy and std::equal
 #include <cstddef> //for std::size_t
 //Provide swap function in both the namespace of swap_test_class
 //(which is the global namespace), and the std namespace.
 //It's common to provide a swap function for a class in both
 //namespaces. Scott Meyers recommends doing so: Effective C++,
 //Third Edition, item 25, "Consider support for a non-throwing swap".
 void swap(swap_test_class& left, swap_test_class& right)
 {
  left.swap(right);
 }
 namespace std
 {
  template <>
  void swap(swap_test_class& left, swap_test_class& right)
  {
    left.swap(right);
  }
 }
 int test_main(int, char*[])
 {
  const std::size_t array_size = 2;
  const swap_test_class initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
  const swap_test_class initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
  swap_test_class array1[array_size];
  swap_test_class array2[array_size];
  std::copy(initial_array1, initial_array1 + array_size, array1);
  std::copy(initial_array2, initial_array2 + array_size, array2);
  swap_test_class::reset();
  boost::swap(array1, array2);
  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
  BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), array_size);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
  return 0;
 }
--- a/swap/test/array_of_int.cpp
+++ b/swap/test/array_of_int.cpp
@ -0,0 +1,35 @@
 // Copyright (c) 2008 Joseph Gauterin, Niels Dekker
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // Tests swapping an array of integers by means of boost::swap.
 #include <boost/utility/swap.hpp>
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 #include <algorithm> //for std::copy and std::equal
 #include <cstddef> //for std::size_t
 int test_main(int, char*[])
 {
  const std::size_t array_size = 3;
  const int initial_array1[array_size] = { 1, 2, 3 };
  const int initial_array2[array_size] = { 4, 5, 6 };
  int array1[array_size];
  int array2[array_size];
  std::copy(initial_array1, initial_array1 + array_size, array1);
  std::copy(initial_array2, initial_array2 + array_size, array2);
  boost::swap(array1, array2);
  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
  BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
  return 0;
 }
--- a/swap/test/array_of_template.cpp
+++ b/swap/test/array_of_template.cpp
@ -0,0 +1,71 @@
 // Copyright (c) 2008 Joseph Gauterin, Niels Dekker
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // Tests swapping an array of swap_test_template<int> objects by means of boost::swap.
 #include <boost/utility/swap.hpp>
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 //Put test class in the global namespace
 #include "./swap_test_class.hpp"
 #include <algorithm> //for std::copy and std::equal
 #include <cstddef> //for std::size_t
 template <class T>
 class swap_test_template
 {
 public:
  typedef T template_argument;
  swap_test_class swap_test_object;
 };
 template <class T>
 inline bool operator==(const swap_test_template<T> & lhs, const swap_test_template<T> & rhs)
 {
  return lhs.swap_test_object == rhs.swap_test_object;
 }
 template <class T>
 inline bool operator!=(const swap_test_template<T> & lhs, const swap_test_template<T> & rhs)
 {
  return !(lhs == rhs);
 }
 //Provide swap function in the namespace of swap_test_template
 //(which is the global namespace).  Note that it isn't allowed to put
 //an overload of this function within the std namespace.
 template <class T>
 void swap(swap_test_template<T>& left, swap_test_template<T>& right)
 {
  left.swap_test_object.swap(right.swap_test_object);
 }
 int test_main(int, char*[])
 {
  const std::size_t array_size = 2;
  const swap_test_template<int> initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
  const swap_test_template<int> initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
  swap_test_template<int> array1[array_size];
  swap_test_template<int> array2[array_size];
  std::copy(initial_array1, initial_array1 + array_size, array1);
  std::copy(initial_array2, initial_array2 + array_size, array2);
  swap_test_class::reset();
  boost::swap(array1, array2);
  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
  BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));
  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), array_size);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
  return 0;
 }
--- a/swap/test/lib_header_1.cpp
+++ b/swap/test/lib_header_1.cpp
@ -0,0 +1,10 @@
 // Copyright (c) 2007 Joseph Gauterin
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // Tests that the swap header compiles as a standalone translation unit
 #include <boost/utility/swap.hpp>
--- a/swap/test/lib_header_2.cpp
+++ b/swap/test/lib_header_2.cpp
@ -0,0 +1,11 @@
 // Copyright (c) 2007 Joseph Gauterin
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // Tests that the swap header include guards work correctly
 #include <boost/utility/swap.hpp>
 #include <boost/utility/swap.hpp>
--- a/swap/test/mixed_headers_1.cpp
+++ b/swap/test/mixed_headers_1.cpp
@ -0,0 +1,11 @@
 // Copyright (c) 2007 Joseph Gauterin
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // Tests that the swap headers work when both are included
 #include <boost/swap.hpp>
 #include <boost/utility/swap.hpp>
--- a/swap/test/mixed_headers_2.cpp
+++ b/swap/test/mixed_headers_2.cpp
@ -0,0 +1,12 @@
 // Copyright (c) 2007 Joseph Gauterin
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // Tests that the swap headers work when both are included
 #include <boost/utility/swap.hpp>
 #include <boost/swap.hpp>
--- a/swap/test/no_ambiguity_in_boost.cpp
+++ b/swap/test/no_ambiguity_in_boost.cpp
@ -0,0 +1,44 @@
 // Copyright (c) 2008 Joseph Gauterin, Niels Dekker
 //
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // boost::swap internally does an unqualified function call to swap.
 // This could have led to ambiguity or infinite recursion, when the
 // objects to be swapped would themselves be from the boost namespace.
 // If so, boost::swap itself might be found by argument dependent lookup.
 // The implementation of boost::swap resolves this issue by giving
 // boost::swap two template argumetns, thereby making it less specialized
 // than std::swap.
 #include <boost/utility/swap.hpp>
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 //Put test class in namespace boost
 namespace boost
 {
  #include "./swap_test_class.hpp"
 }
 int test_main(int, char*[])
 {
  const boost::swap_test_class initial_value1(1);
  const boost::swap_test_class initial_value2(2);
  boost::swap_test_class object1 = initial_value1;
  boost::swap_test_class object2 = initial_value2;
  boost::swap_test_class::reset();
  boost::swap(object1,object2);
  BOOST_CHECK(object1 == initial_value2);
  BOOST_CHECK(object2 == initial_value1);
  BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),0);
  BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),3);
  return 0;
 }
--- a/Show More
+++ b/Show More
		`@ -0,0 +1 @@`
							`The existance of this file tells the regression reporting programs that the directory contains sub-directories which are libraries.`