Added traits arguments to the iterator adaptor classes for vc++ port.

[SVN r7671]
A first stab at vc6 compatibility
2025-06-28 21:41:13 +02:00 · 2000-08-01 00:45:42 +00:00 · 2000-07-31 15:39:33 +00:00 · 2000-07-27 18:35:03 +00:00 · 2000-07-27 17:59:40 +00:00 · 2000-07-26 20:32:15 +00:00
24 changed files with 278 additions and 3653 deletions
--- a/CopyConstructible.html
+++ b/CopyConstructible.html
@ -1,188 +0,0 @@
 <HTML>
 <!--
  -- Copyright (c) Jeremy Siek 2000
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  Silicon Graphics makes no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  -->
 <Head>
 <Title>CopyConstructible</Title>
 </HEAD>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
 <IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost"> 
 <!--end header-->
 <BR Clear>
 <H1>CopyConstructible</H1>
 <h3>Description</h3>
 A type is CopyConstructible if it is possible to copy objects of that
 type.
 <h3>Notation</h3>
 <Table>
 <TR>
 <TD VAlign=top>
 <tt>T</tt>
 </TD>
 <TD VAlign=top>
 is type that is a model of CopyConstructible
 </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>
 <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>
 </table>
 <h3>Models</h3>
 <UL>
 <LI><tt>int</tt>
 <LI><tt>std::pair</tt>
 </UL>
 <h3>See also</h3>
 <A
 href="http://www.sgi.com/Technology/STL/DefaultConstructible.html">DefaultConstructible</A>
 and 
 <A href="http://www.sgi.com/Technology/STL/Assignable.html">Assignable</A>
 <br>
 <HR>
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy 2000</TD><TD>
 <A HREF=http://www.lsc.nd.edu/~jsiek>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
 </TD></TR></TABLE>
 </BODY>
 </HTML> 
--- a/MultiPassInputIterator.html
+++ b/MultiPassInputIterator.html
@ -1,92 +0,0 @@
 <HTML>
 <!--
  -- Copyright (c) Jeremy Siek 2000
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  Silicon Graphics makes no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  -->
 <Head>
 <Title>MultiPassInputIterator</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
 	ALINK="#ff0000"> 
 <IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost"> 
 <BR Clear>
 <H2>
 <A NAME="concept:MultiPassInputIterator"></A>
 MultiPassInputIterator
 </H2>
 This concept is a refinement of <a
 href="http://www.sgi.com/Technology/STL/InputIterator.html">InputIterator</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
 MultiPassInputIterator is very similar to the <a
 href="http://www.sgi.com/Technology/STL/ForwardIterator.hmtl">ForwardIterator</a>. The
 only difference is that a <a
 href="http://www.sgi.com/Technology/STL/ForwardIterator.hmtl">ForwardIterator</a>
 requires the <TT>reference</TT> type to be <TT>value_type&amp;</TT>, whereas
 MultiPassInputIterator is like <a
 href="http://www.sgi.com/Technology/STL/InputIterator.html">InputIterator</a>
 in that the <TT>reference</TT> type merely has to be convertible to
 <TT>value_type</TT>.
 <h3>Design Notes</h3>
 comments by Valentin Bonnard:
 <p> I think that introducing MultiPassInputIterator isn't the right
 solution. Do you also want to define MultiPassBidirectionnalIterator
 and MultiPassRandomAccessIterator ? I don't, definitly. It only
 confuses the issue. The problem lies into the existing hierarchy of
 iterators, which mixes movabillity, modifiabillity and lvalue-ness,
 and these are clearly independant.
 <p> The terms Forward, Bidirectionnal and RandomAccess 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 MultiPassInputIterator
 is just called a ForwardIterator.
 <p>                
 Other translations are:<br>
 std::ForwardIterator -> ForwardIterator & LvalueIterator<br>
 std::BidirectionnalIterator -> BidirectionnalIterator & LvalueIterator<br>
 std::RandomAccessIterator -> RandomAccessIterator & LvalueIterator<br>
 <p>
 Note that in practice the only operation not allowed on my 
 ForwardIterator which is allowed on std::ForwardIterator is 
 <tt>&*it</tt>. I think that <tt>&*</tt> is rarely needed in generic code.
 <p>
 reply by Jeremy Siek:
 <p>
 The above analysis by Valentin is right on. Of course, there is
 the problem with backward compatibility. The current STL implementations
 are based on the old definition of ForwardIterator. The right course
 of action is to get ForwardIterator, etc. changed in the C++ standard.
 Once that is done we can drop MultiPassInputIterator.
 <br>
 <HR>
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy 2000</TD><TD>
 <A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
 </TD></TR></TABLE>
 </BODY>
 </HTML> 
--- a/algo_opt_examples.cpp
+++ b/algo_opt_examples.cpp
@ -53,7 +53,7 @@ using std::cin;
 namespace opt{
 //
-// algorithm destroy_array:
+// algorithm destroy_arry:
 // The reverse of std::unitialized_copy, takes a block of
 // unitialized memory and calls destructors on all objects therein.
 //
--- 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
@ -1,738 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type"
 content="text/html; charset=iso-8859-1">
 <meta name="Template"
 content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
 <meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
 <title>Call Traits</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
 vlink="#800080">
 <h1><img src="../../c++boost.gif" 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
 defined inside namespace boost.</p>
 <p>The template class call_traits&lt;T&gt; encapsulates the
 &quot;best&quot; method to pass a parameter of some type T to or
 from a function, and consists of a collection of typedefs defined
 as in the table below. The purpose of call_traits is to ensure
 that problems like &quot;<a href="#refs">references to references</a>&quot;
 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
 specialization, 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.</p>
 <table border="0" cellpadding="7" cellspacing="1" width="797">
    <tr>
        <td valign="top" width="17%" bgcolor="#008080"><p
        align="center">Existing practice</p>
        </td>
        <td valign="top" width="35%" bgcolor="#008080"><p
        align="center">call_traits equivalent</p>
        </td>
        <td valign="top" width="32%" bgcolor="#008080"><p
        align="center">Description</p>
        </td>
        <td valign="top" width="16%" bgcolor="#008080"><p
        align="center">Notes</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%"><p align="center">T<br>
        (return by value)</p>
        </td>
        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::value_type</code></p>
        </td>
        <td valign="top" width="32%">Defines a type that
        represents the &quot;value&quot; of type T. Use this for
        functions that return by value, or possibly for stored
        values of type T.</td>
        <td valign="top" width="16%"><p align="center">2</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%"><p align="center">T&amp;<br>
        (return value)</p>
        </td>
        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::reference</code></p>
        </td>
        <td valign="top" width="32%">Defines a type that
        represents a reference to type T. Use for functions that
        would normally return a T&amp;.</td>
        <td valign="top" width="16%"><p align="center">1</p>
        </td>
    </tr>
    <tr>
        <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>
        </td>
        <td valign="top" width="32%">Defines a type that
        represents a constant reference to type T. Use for
        functions that would normally return a const T&amp;.</td>
        <td valign="top" width="16%"><p align="center">1</p>
        </td>
    </tr>
    <tr>
        <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>
        </td>
        <td valign="top" width="32%">Defines a type that
        represents the &quot;best&quot; way to pass a parameter
        of type T to a function.</td>
        <td valign="top" width="16%"><p align="center">1,3</p>
        </td>
    </tr>
 </table>
 <p>Notes:</p>
 <ol>
    <li>If T is already reference type, then call_traits is
        defined such that <a href="#refs">references to
        references</a> do not occur (requires partial
        specialization).</li>
    <li>If T is an array type, then call_traits defines <code>value_type</code>
        as a &quot;constant pointer to type&quot; rather than an
        &quot;array of type&quot; (requires partial
        specialization). Note that if you are using value_type as
        a stored value then this will result in storing a &quot;constant
        pointer to an array&quot; rather than the array itself.
        This may or may not be a good thing depending upon what
        you actually need (in other words take care!).</li>
    <li>If T is a small built in type or a pointer, then <code>param_type</code>
        is defined as <code>T const</code>, instead of <code>T
        const&amp;</code>. This can improve the ability of the
        compiler to optimize loops in the body of the function if
        they depend upon the passed parameter, the semantics of
        the passed parameter is otherwise unchanged (requires
        partial specialization).</li>
 </ol>
 <p>&nbsp;</p>
 <h3>Copy constructibility</h3>
 <p>The following table defines which call_traits types can always
 be copy-constructed from which other types, those entries marked
 with a '?' are true only if and only if T is copy constructible:</p>
 <table border="0" cellpadding="7" cellspacing="1" width="766">
    <tr>
        <td valign="top" width="17%">&nbsp;</td>
        <td valign="top" colspan="5" width="85%"
        bgcolor="#008080"><p align="center">To:</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#008080">From:</td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">T</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">value_type</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">reference</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">const_reference</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">param_type</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">T</td>
        <td valign="top" width="17%"><p align="center">?</p>
        </td>
        <td valign="top" width="17%"><p align="center">?</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">value_type</td>
        <td valign="top" width="17%"><p align="center">?</p>
        </td>
        <td valign="top" width="17%"><p align="center">?</p>
        </td>
        <td valign="top" width="17%"><p align="center">N</p>
        </td>
        <td valign="top" width="17%"><p align="center">N</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">reference</td>
        <td valign="top" width="17%"><p align="center">?</p>
        </td>
        <td valign="top" width="17%"><p align="center">?</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">const_reference</td>
        <td valign="top" width="17%"><p align="center">?</p>
        </td>
        <td valign="top" width="17%"><p align="center">N</p>
        </td>
        <td valign="top" width="17%"><p align="center">N</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">param_type</td>
        <td valign="top" width="17%"><p align="center">?</p>
        </td>
        <td valign="top" width="17%"><p align="center">?</p>
        </td>
        <td valign="top" width="17%"><p align="center">N</p>
        </td>
        <td valign="top" width="17%"><p align="center">N</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <p>If T is an assignable type the following assignments are
 possible:</p>
 <table border="0" cellpadding="7" cellspacing="1" width="766">
    <tr>
        <td valign="top" width="17%">&nbsp;</td>
        <td valign="top" colspan="5" width="85%"
        bgcolor="#008080"><p align="center">To:</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#008080">From:</td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">T</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">value_type</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">reference</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">const_reference</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">param_type</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">T</td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">value_type</td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">reference</td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">const_reference</td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0">param_type</td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">Y</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
        <td valign="top" width="17%"><p align="center">-</p>
        </td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <h3><a name="examples"></a>Examples</h3>
 <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
 can not be used with reference or array types.</p>
 <table border="0" cellpadding="7" cellspacing="1" width="766">
    <tr>
        <td valign="top" width="17%">&nbsp;</td>
        <td valign="top" colspan="5" width="85%"
        bgcolor="#008080"><p align="center">Call_traits type:</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#008080"><p
        align="center">Original type T</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">value_type</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">reference</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">const_reference</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">param_type</p>
        </td>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">Applies to:</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">myclass</p>
        </td>
        <td valign="top" width="17%"><p align="center">myclass</p>
        </td>
        <td valign="top" width="17%"><p align="center">myclass&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">const
        myclass&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">myclass
        const&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">All user
        defined types.</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">int</p>
        </td>
        <td valign="top" width="17%"><p align="center">int</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>
        <td valign="top" width="17%"><p align="center">int const</p>
        </td>
        <td valign="top" width="17%"><p align="center">All small
        built-in types.</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">int*</p>
        </td>
        <td valign="top" width="17%"><p align="center">int*</p>
        </td>
        <td valign="top" width="17%"><p align="center">int*&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">int*const&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">int* const</p>
        </td>
        <td valign="top" width="17%"><p align="center">All
        pointer types.</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">int&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">int&amp;</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>
        <td valign="top" width="17%"><p align="center">int&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">All
        reference types.</p>
        </td>
    </tr>
    <tr>
        <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>
        <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>
        <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>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">int[3]</p>
        </td>
        <td valign="top" width="17%"><p align="center">const int*</p>
        </td>
        <td valign="top" width="17%"><p align="center">int(&amp;)[3]</p>
        </td>
        <td valign="top" width="17%"><p align="center">const int(&amp;)[3]</p>
        </td>
        <td valign="top" width="17%"><p align="center">const int*
        const</p>
        </td>
        <td valign="top" width="17%"><p align="center">All array
        types.</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">const int[3]</p>
        </td>
        <td valign="top" width="17%"><p align="center">const int*</p>
        </td>
        <td valign="top" width="17%"><p align="center">const int(&amp;)[3]</p>
        </td>
        <td valign="top" width="17%"><p align="center">const int(&amp;)[3]</p>
        </td>
        <td valign="top" width="17%"><p align="center">const int*
        const</p>
        </td>
        <td valign="top" width="17%"><p align="center">All
        constant-array types.</p>
        </td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <h4>Example 1:</h4>
 <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
 typedefs may be used:</p>
 <pre>template &lt;class T&gt;
 struct contained
 {
   // define our typedefs first, arrays are stored by value
   // so value_type is not the same as result_type:
   typedef typename boost::call_traits&lt;T&gt;::param_type       param_type;
   typedef typename boost::call_traits&lt;T&gt;::reference        reference;
   typedef typename boost::call_traits&lt;T&gt;::const_reference  const_reference;
   typedef T                                                value_type;
   typedef typename boost::call_traits&lt;T&gt;::value_type       result_type;
   // stored value:
   value_type v_;
   // constructors:
   contained() {}
   contained(param_type p) : v_(p){}
   // return byval:
   result_type value() { return v_; }
   // return by_ref:
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
   // pass value:
   void call(param_type p){}
 };</pre>
 <h4><a name="refs"></a>Example 2 (the reference to reference
 problem):</h4>
 <p>Consider the definition of std::binder1st:</p>
 <pre>template &lt;class Operation&gt; 
 class binder1st : 
   public unary_function&lt;Operation::second_argument_type, Operation::result_type&gt; 
 { 
 protected: 
   Operation op; 
   Operation::first_argument_type value; 
 public: 
   binder1st(const Operation&amp; x, const Operation::first_argument_type&amp; y); 
   Operation::result_type operator()(const Operation::second_argument_type&amp; x) const; 
 }; </pre>
 <p>Now consider what happens in the relatively common case that
 the functor takes its second argument as a reference, that
 implies that <code>Operation::second_argument_type</code> is a
 reference type, <code>operator()</code> will now end up taking a
 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>
 <p>Now in the case that <code>Operation::second_argument_type</code>
 is a reference type, the argument is passed as a reference, and
 the no &quot;reference to reference&quot; occurs.</p>
 <h4><a name="ex3"></a>Example 3 (the make_pair problem):</h4>
 <p>If we pass the name of an array as one (or both) arguments to <code>std::make_pair</code>,
 then template argument deduction deduces the passed parameter as
 &quot;const reference to array of T&quot;, this also applies to
 string literals (which are really array literals). Consequently
 instead of returning a pair of pointers, it tries to return a
 pair of arrays, and since an array type is not copy-constructible
 the code fails to compile. One solution is to explicitly cast the
 arguments to make_pair to pointers, but call_traits provides a
 better (i.e. automatic) solution (and one that works safely even
 in generic code where the cast might do the wrong thing):</p>
 <pre>template &lt;class T1, class T2&gt;
 std::pair&lt;
   typename boost::call_traits&lt;T1&gt;::value_type, 
   typename boost::call_traits&lt;T2&gt;::value_type&gt; 
      make_pair(const T1&amp; t1, const T2&amp; t2)
 {
   return std::pair&lt;
      typename boost::call_traits&lt;T1&gt;::value_type, 
      typename boost::call_traits&lt;T2&gt;::value_type&gt;(t1, t2);
 }</pre>
 <p>Here, the deduced argument types will be automatically
 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>
 <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>),
 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
 used, but with the passed parameter &quot;optimized&quot; using
 call_traits:</p>
 <pre>namespace detail{
 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);
   {
      while(first != last)
      {
         *first = val;
         ++first;
      }
   }
 };
 template &lt;&gt;
 struct filler&lt;true&gt;
 {
   template &lt;typename I, typename T&gt;
   static void do_fill(I first, I last, T val)
   {
      memset(first, val, last-first);
   }
 };
 }
 template &lt;class I, class T&gt;
 inline void fill(I first, I last, const T&amp; val)
 {
   enum{ can_opt = boost::is_pointer&lt;I&gt;::value
                   &amp;&amp; boost::is_arithmetic&lt;T&gt;::value
                   &amp;&amp; (sizeof(T) == 1) };
   typedef detail::filler&lt;can_opt&gt; filler_t;
   filler_t::template do_fill&lt;I,T&gt;(first, last, val);
 }</pre>
 <p>Footnote: the reason that this is &quot;optimal&quot; for
 small built-in types is that with the value passed as &quot;T
 const&quot; instead of &quot;const T&amp;&quot; the compiler is
 able to tell both that the value is constant and that it is free
 of aliases. With this information the compiler is able to cache
 the passed value in a register, unroll the loop, or use
 explicitly parallel instructions: if any of these are supported.
 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>
 <h3>Rationale</h3>
 <p>The following notes are intended to briefly describe the
 rational behind choices made in call_traits.</p>
 <p>All user-defined types follow &quot;existing practice&quot;
 and need no comment.</p>
 <p>Small built-in types (what the standard calls fundamental
 types [3.9.1]) differ from existing practice only in the <i>param_type</i>
 typedef. In this case passing &quot;T const&quot; is compatible
 with existing practice, but may improve performance in some cases
 (see <a href="#ex4">Example 4</a>), in any case this should never
 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
 members must be defined such that these problems do not occur.
 There is a proposal to modify the language such that &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
 other words it's a workaround).</p>
 <p>For array types, a function that takes an array as an argument
 will degrade the array type to a pointer type: this means that
 the type of the actual parameter is different from its declared
 type, something that can cause endless problems in template code
 that relies on the declared type of a parameter. For example:</p>
 <pre>template &lt;class T&gt;
 struct A
 {
   void foo(T t);
 };</pre>
 <p><font face="Times New Roman">In this case if we instantiate A&lt;int[2]&gt;
 then the declared type of the parameter passed to member function
 foo is int[2], but it's actual type is const int*, if we try to
 use the type T within the function body, then there 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)
 {
   T dup(t); // doesn't compile for case that T is an array.
 }</pre>
 <p>By using call_traits the degradation from array to pointer is
 explicit, and the type of the parameter is the same as it's
 declared type:</p>
 <pre>template &lt;class T&gt;
 struct A
 {
   void foo(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)
 {
   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
 returned, not a copy of the whole array, and again call_traits
 makes the degradation explicit. The value_type member is useful
 whenever an array must be explicitly degraded to a pointer - <a
 href="#ex3">Example 3</a> provides the test case (Footnote: the
 array specialisation for call_traits is the least well understood
 of all the call_traits specialisations, if the given semantics
 cause specific problems for you, or don't solve a particular
 array-related problem, then I would be interested to hear about
 it. Most people though will probably never need to use this
 specialisation).</p>
 <hr>
 <p>Revised 18 June 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>.</p>
 <p>&nbsp;</p>
 <p>&nbsp;</p>
 </body>
 </html>
--- a/call_traits_test.cpp
+++ b/call_traits_test.cpp
@ -1,11 +1,3 @@
 // boost::compressed_pair test program   
 //  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
 //  distribute this software is granted provided this copyright notice appears   
 //  in all copies. This software is provided "as is" without express or implied   
 //  warranty, and with no claim as to its suitability for any purpose.   
 // standalone test program for <boost/call_traits.hpp>
 #include <cassert>
 #include <iostream>
@ -14,7 +6,12 @@
 #include <typeinfo>
 #include <boost/call_traits.hpp>
-#include "type_traits_test.hpp"
+#ifdef __BORLANDC__
 // turn off some warnings, the way we do the tests will generate a *lot* of these
 // this is a result of the tests not call_traits itself....
 #pragma option -w-8004 -w-ccc -w-rch -w-eff -w-aus
 #endif
 //
 // 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:
@ -181,6 +178,30 @@ struct UDT
   bool operator == (const UDT& v){ return v.i_ == i_; }
 };
 //
 // define tests here
 unsigned failures = 0;
 unsigned test_count = 0;
 #define value_test(v, x) ++test_count;\
                         if(v != x){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #define type_test(v, x)  ++test_count;\
                           if(boost::is_same<v, x>::value == false){\
                           ++failures; \
                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
                           std::cout << "   expected type was " << #v << std::endl; \
                           std::cout << "   " << typeid(boost::is_same<v, x>).name() << "::value is false" << std::endl; }
 #else
 #define type_test(v, x)  ++test_count;\
                         if(typeid(v) != typeid(x)){\
                           ++failures; \
                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
                           std::cout << "   expected type was " << #v << std::endl; \
                           std::cout << "   " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
 #endif
 int main()
 {
   checker<UDT> c1;
@ -240,7 +261,7 @@ int main()
   type_test(const int&, boost::call_traits<cr_type>::const_reference)
   type_test(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;
+   std::cout << "GNU C++ cannot instantiate call_traits<cr_type>, skipping four tests (4 errors)" << std::endl;
   failures += 4;
   test_count += 4;
 #endif
@ -274,47 +295,37 @@ int main()
 template <typename T, bool isarray = false>
 struct call_traits_test
 {
-   typedef ::boost::call_traits<T> ct;
+   static void assert_construct(boost::call_traits<T>::param_type val);
   typedef typename ct::param_type param_type;
   typedef typename ct::reference reference;
   typedef typename ct::const_reference const_reference;
   typedef typename ct::value_type value_type;
   static void assert_construct(param_type val);
 };
 template <typename T, bool isarray>
-void call_traits_test<T, isarray>::assert_construct(typename call_traits_test<T, isarray>::param_type val)
+void call_traits_test<T, isarray>::assert_construct(boost::call_traits<T>::param_type val)
 {
   //
   // this is to check that the call_traits assertions are valid:
   T t(val);
-   value_type v(t);
+   boost::call_traits<T>::value_type v(t);
-   reference r(t);
+   boost::call_traits<T>::reference r(t);
-   const_reference cr(t);
+   boost::call_traits<T>::const_reference cr(t);
-   param_type p(t);
+   boost::call_traits<T>::param_type p(t);
-   value_type v2(v);
+   boost::call_traits<T>::value_type v2(v);
-   value_type v3(r);
+   boost::call_traits<T>::value_type v3(r);
-   value_type v4(p);
+   boost::call_traits<T>::value_type v4(p);
-   reference r2(v);
+   boost::call_traits<T>::reference r2(v);
-   reference r3(r);
+   boost::call_traits<T>::reference r3(r);
-   const_reference cr2(v);
+   boost::call_traits<T>::const_reference cr2(v);
-   const_reference cr3(r);
+   boost::call_traits<T>::const_reference cr3(r);
-   const_reference cr4(cr);
+   boost::call_traits<T>::const_reference cr4(cr);
-   const_reference cr5(p);
+   boost::call_traits<T>::const_reference cr5(p);
-   param_type p2(v);
+   boost::call_traits<T>::param_type p2(v);
-   param_type p3(r);
+   boost::call_traits<T>::param_type p3(r);
-   param_type p4(p);
+   boost::call_traits<T>::param_type p4(p);
 }
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <typename T>
 struct call_traits_test<T, true>
 {
-   typedef ::boost::call_traits<T> ct;
+   static void assert_construct(boost::call_traits<T>::param_type val);
   typedef typename ct::param_type param_type;
   typedef typename ct::reference reference;
   typedef typename ct::const_reference const_reference;
   typedef typename ct::value_type value_type;
   static void assert_construct(param_type val);
 };
 template <typename T>
@ -323,25 +334,26 @@ void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_ty
   //
   // this is to check that the call_traits assertions are valid:
   T t;
-   value_type v(t);
+   boost::call_traits<T>::value_type v(t);
-   value_type v5(val);
+   boost::call_traits<T>::value_type v5(val);
-   reference r = t;
+   boost::call_traits<T>::reference r = t;
-   const_reference cr = t;
+   boost::call_traits<T>::const_reference cr = t;
-   reference r2 = r;
+   boost::call_traits<T>::reference r2 = r;
   #ifndef __BORLANDC__
   // C++ Builder buglet:
-   const_reference cr2 = r;
+   boost::call_traits<T>::const_reference cr2 = r;
   #endif
-   param_type p(t);
+   boost::call_traits<T>::param_type p(t);
-   value_type v2(v);
+   boost::call_traits<T>::value_type v2(v);
-   const_reference cr3 = cr;
+   boost::call_traits<T>::const_reference cr3 = cr;
-   value_type v3(r);
+   boost::call_traits<T>::value_type v3(r);
-   value_type v4(p);
+   boost::call_traits<T>::value_type v4(p);
-   param_type p2(v);
+   boost::call_traits<T>::param_type p2(v);
-   param_type p3(r);
+   boost::call_traits<T>::param_type p3(r);
-   param_type p4(p);
+   boost::call_traits<T>::param_type p4(p);
 }
 #endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 //
 // now check call_traits assertions by instantiating call_traits_test:
 template struct call_traits_test<int>;
@ -353,3 +365,4 @@ template struct call_traits_test<const int&>;
 template struct call_traits_test<int[2], true>;
 #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/compressed_pair.htm
+++ b/compressed_pair.htm
@ -1,92 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type"
 content="text/html; charset=iso-8859-1">
 <meta name="Template"
 content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
 <meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
 <title>Header <boost/compressed_pair.hpp></title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
 vlink="#800080">
 <h2><img src="../../c++boost.gif" width="276" height="86">Header
 &lt;<a href="../../boost/detail/call_traits.hpp">boost/compressed_pair.hpp</a>&gt;</h2>
 <p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are
 defined inside namespace boost.</p>
 <p>The class compressed pair is very similar to std::pair, but if
 either of the template arguments are empty classes, then the
 &quot;empty 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:
 	typedef T1                                                 first_type;
 	typedef T2                                                 second_type;
 	typedef typename call_traits&lt;first_type&gt;::param_type       first_param_type;
 	typedef typename call_traits&lt;second_type&gt;::param_type      second_param_type;
 	typedef typename call_traits&lt;first_type&gt;::reference        first_reference;
 	typedef typename call_traits&lt;second_type&gt;::reference       second_reference;
 	typedef typename call_traits&lt;first_type&gt;::const_reference  first_const_reference;
 	typedef typename call_traits&lt;second_type&gt;::const_reference second_const_reference;
 	         compressed_pair() : base() {}
 	         compressed_pair(first_param_type x, second_param_type y);
 	explicit compressed_pair(first_param_type x);
 	explicit compressed_pair(second_param_type y);
 	first_reference       first();
 	first_const_reference first() const;
 	second_reference       second();
 	second_const_reference second() const;
 	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 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
@ -5,17 +5,42 @@
 //  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.
 // standalone test program for <boost/compressed_pair.hpp>
 #include <iostream>
 #include <typeinfo>
 #include <cassert>
 #include <boost/compressed_pair.hpp>
 #include "type_traits_test.hpp"
 using namespace boost;
 #ifdef __BORLANDC__
 #pragma option -w-ccc -w-rch -w-eff -w-aus
 #endif
 //
 // define tests here
 unsigned failures = 0;
 unsigned test_count = 0;
 #define value_test(v, x) ++test_count;\
                         if(v != x){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #define type_test(v, x)  ++test_count;\
                         if(boost::is_same<v, x>::value == false){\
                           ++failures; \
                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
                           std::cout << "   expected type was " << #v << std::endl; \
                           std::cout << "   " << typeid(boost::is_same<v, x>).name() << "::value is false" << std::endl; }
 #else
 #define type_test(v, x)  ++test_count;\
                         if(typeid(v) != typeid(x)){\
                           ++failures; \
                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
                           std::cout << "   expected type was " << #v << std::endl; \
                           std::cout << "   " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
 #endif
 struct empty_POD_UDT{};
 struct empty_UDT
 {
@ -85,21 +110,12 @@ int main()
 //
 // instanciate some compressed pairs:
 #ifdef __MWERKS__
 template class compressed_pair<int, double>;
 template class compressed_pair<int, int>;
 template class compressed_pair<empty_UDT, int>;
 template class compressed_pair<int, empty_UDT>;
 template class compressed_pair<empty_UDT, empty_UDT>;
 template class compressed_pair<empty_UDT, empty_POD_UDT>;
 #else
 template class boost::compressed_pair<int, double>;
 template class boost::compressed_pair<int, int>;
 template class boost::compressed_pair<empty_UDT, int>;
 template class boost::compressed_pair<int, empty_UDT>;
 template class boost::compressed_pair<empty_UDT, empty_UDT>;
 template class boost::compressed_pair<empty_UDT, empty_POD_UDT>;
 #endif
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 //
@ -111,17 +127,14 @@ 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();
 #endif // __MWERKS__
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
--- a/include/boost/detail/call_traits.hpp
+++ b/include/boost/detail/call_traits.hpp
@ -6,9 +6,6 @@
 //  See http://www.boost.org for most recent version including documentation.
 // call_traits: defines typedefs for function usage
 // (see libs/utility/call_traits.htm)
 /* Release notes:
   23rd July 2000:
      Fixed array specialization. (JM)
@ -76,7 +73,7 @@ struct call_traits<T&>
   typedef T& param_type;  // hh removed const
 };
-#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
+#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x550)
 // 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
--- a/include/boost/detail/compressed_pair.hpp
+++ b/include/boost/detail/compressed_pair.hpp
@ -6,8 +6,6 @@
 //  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 2000:
 // Removed default arguments from compressed_pair_switch to get
--- a/include/boost/detail/ob_call_traits.hpp
+++ b/include/boost/detail/ob_call_traits.hpp
@ -7,7 +7,6 @@
 //  See http://www.boost.org for most recent version including documentation.
 //
 //  Crippled version for crippled compilers:
 //  see libs/utility/call_traits.htm
 //
 #ifndef BOOST_OB_CALL_TRAITS_HPP
 #define BOOST_OB_CALL_TRAITS_HPP
--- a/include/boost/detail/ob_compressed_pair.hpp
+++ b/include/boost/detail/ob_compressed_pair.hpp
@ -5,7 +5,6 @@
 //  warranty, and with no claim as to its suitability for any purpose.
 //  See http://www.boost.org for most recent version including documentation.
 //  see libs/utility/compressed_pair.hpp
 //
 /* Release notes:
   23rd July 2000:
--- a/include/boost/utility.hpp
+++ b/include/boost/utility.hpp
@ -24,7 +24,6 @@
 #include <boost/config.hpp>
 #include <cstddef>            // for size_t
 #include <utility>            // for std::pair
 namespace boost
 {
@ -64,32 +63,6 @@ namespace boost
        const noncopyable& operator=( const noncopyable& );
    }; // noncopyable
 //  class tied  -------------------------------------------------------//
    // A helper for conveniently assigning the two values from a pair
    // into separate variables. The idea for this comes from Jaakko J<>rvi's
    // Binder/Lambda Library.
    // Constributed by Jeremy Siek
    template <class A, class B>
    class tied {
    public:
      inline tied(A& a, B& b) : _a(a), _b(b) { }
      template <class U, class V>
      inline tied& operator=(const std::pair<U,V>& p) {
 	_a = p.first;
 	_b = p.second;
 	return *this;
      }
    protected:
      A& _a;
      B& _b;
    };
    template <class A, class B>
    inline tied<A,B> tie(A& a, B& b) { return tied<A,B>(a, b); }
 } // namespace boost
 #endif  // BOOST_UTILITY_HPP
--- 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/iterator_adaptor_test.cpp
+++ b/iterator_adaptor_test.cpp
@ -0,0 +1,143 @@
 //  Demonstrate and test boost/operators.hpp on std::iterators  -------------//
 //  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
 //  sell and distribute this software is granted provided this
 //  copyright notice appears in all copies. This software is provided
 //  "as is" without express or implied warranty, and with no claim as
 //  to its suitability for any purpose.
 //  See http://www.boost.org for most recent version including documentation.
 //  Revision History
 //  13 Jun 00 Added const version of the iterator tests (Jeremy Siek)
 //  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
 #include <iostream>
 #include <algorithm>
 #include <functional>
 #include <boost/iterator_adaptors.hpp>
 #include <boost/iterator_tests.hpp>
 struct my_iterator_tag : public std::random_access_iterator_tag { };
 using boost::dummyT;
 struct my_iter_traits {
  typedef dummyT value_type;
  typedef dummyT* pointer;
  typedef dummyT& reference;
  typedef my_iterator_tag iterator_category;
  typedef std::ptrdiff_t difference_type;
 };
 struct my_const_iter_traits {
  typedef dummyT value_type;
  typedef const dummyT* pointer;
  typedef const dummyT& reference;
  typedef my_iterator_tag iterator_category;
  typedef std::ptrdiff_t difference_type;
 };
 typedef boost::iterator_adaptors
  <dummyT*, const dummyT*, 
   my_iter_traits, my_const_iter_traits> My;
 struct mult_functor {
  typedef int result_type;
  typedef int argument_type;
  // Functors used with transform_iterator must be
  // DefaultConstructible, as the transform_iterator must be
  // DefaultConstructible to satisfy the requirements for
  // TrivialIterator.
  mult_functor() { }
  mult_functor(int aa) : a(aa) { }
  int operator()(int b) const { return a * b; }
  int a;
 };
 int
 main()
 {
  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
 		     dummyT(3), dummyT(4), dummyT(5) };
  const int N = sizeof(array)/sizeof(dummyT);
  // sanity check, if this doesn't pass the test is buggy
  boost::random_access_iterator_test(array,N,array);
  // Test the iterator_adaptors
  {
    My::iterator i = array;
    boost::random_access_iterator_test(i, N, array);
    My::const_iterator j = array;
    boost::random_access_iterator_test(j, N, array);
    boost::const_nonconst_iterator_test(i, ++j);
  }
  // Test transform_iterator
  {
    int x[N], y[N];
    for (int k = 0; k < N; ++k)
      x[k] = k;
    std::copy(x, x + N, y);
    for (int k2 = 0; k2 < N; ++k2)
      x[k2] = x[k2] * 2;
    boost::transform_iterator<mult_functor, int*,
      boost::iterator<std::random_access_iterator_tag,int> >::type
      i(y, mult_functor(2));
    boost::random_access_iterator_test(i, N, x);
  }
  // Test indirect_iterator
  {
    dummyT* ptr[N];
    for (int k = 0; k < N; ++k)
      ptr[k] = array + k;
    typedef dummyT* DummyPtr;
    typedef boost::indirect_iterators<DummyPtr*, const DummyPtr*,
      boost::iterator<std::random_access_iterator_tag, DummyPtr>,
      boost::iterator<std::random_access_iterator_tag, const DummyPtr>,
      boost::iterator<std::random_access_iterator_tag, dummyT>
      > Indirect;
    Indirect::iterator i = ptr;
    boost::random_access_iterator_test(i, N, array);
    Indirect::const_iterator j = ptr;
    boost::random_access_iterator_test(j, N, array);
    boost::const_nonconst_iterator_test(i, ++j);    
  }
  // Test reverse_iterators
  {
    dummyT reversed[N];
    std::copy(array, array + N, reversed);
    std::reverse(reversed, reversed + N);
    typedef boost::reverse_iterators<dummyT*, const dummyT*,
      boost::iterator<std::random_access_iterator_tag,dummyT>,
      boost::iterator<std::random_access_iterator_tag,const dummyT>
      > Reverse;
    Reverse::iterator i = reversed + N;
    boost::random_access_iterator_test(i, N, array);
    Reverse::const_iterator j = reversed + N;
    boost::random_access_iterator_test(j, N, array);
    boost::const_nonconst_iterator_test(i, ++j);    
  }
  // Test integer_range's iterators
  {
    int int_array[] = { 0, 1, 2, 3, 4, 5 };
    boost::integer_range<int> r(0, 5);
    boost::random_access_iterator_test(r.begin(), r.size(), int_array);
  }
  std::cout << "test successful " << std::endl;
  return 0;
 }
--- a/iterator_adaptors.htm
+++ b/iterator_adaptors.htm
@ -9,13 +9,15 @@
 <body bgcolor="#FFFFFF" text="#000000">
-<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
-align="center" width="277" height="86">
+<a href="../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a></h1>
-<h1>Header
+<p>Header <a
-<a href="../../boost/pending/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a></h1>
+href="http://www.boost.org/boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
 </p>
-<p>The file <tt>boost/iterator_adaptors.hpp</tt>
+<p>The file <a
 href="http://www.boost.org/boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
 includes the main <tt>iterator_adaptors</tt> class and several other classes
 for constructing commonly used iterator adaptors.</p>
--- a/operators.htm
+++ b/operators.htm
@ -1,598 +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/operators.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/operators.hpp">boost/operators.hpp</a></h1>
 <p>Header <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>
 supplies (in namespace boost) several sets of templates:</p>
 <ul>
  <li><a href="#Arithmetic">Arithmetic operators</a>.
  <li><a href="#deref and helpers">Dereference operators and iterator helpers.</a></li>
 </ul>
 <p>These templates define many global operators in terms of a minimal number of
 fundamental operators.</p>
 <h1><a name="Arithmetic">Arithmetic</a> Operators</h1>
 <p>If, for example, you declare a class like this:</p>
 <blockquote>
  <pre>class MyInt : boost::operators&lt;MyInt&gt;
 {
    bool operator&lt;(const MyInt&amp; x) const; 
    bool operator==(const MyInt&amp; x) const;
    MyInt&amp; operator+=(const MyInt&amp; x);    
    MyInt&amp; operator-=(const MyInt&amp; x);    
    MyInt&amp; operator*=(const MyInt&amp; x);    
    MyInt&amp; operator/=(const MyInt&amp; x);    
    MyInt&amp; operator%=(const MyInt&amp; x);    
    MyInt&amp; operator|=(const MyInt&amp; x);    
    MyInt&amp; operator&amp;=(const MyInt&amp; x);    
    MyInt&amp; operator^=(const MyInt&amp; x);    
    MyInt&amp; operator++();    
    MyInt&amp; operator--();    
 };</pre>
 </blockquote>
 <p>then the <code>operators&lt;&gt;</code> template adds more than a dozen
 additional operators, such as operator&gt;, &lt;=, &gt;=, and +.&nbsp; <a href="#two_arg">Two-argument
 forms</a> of the templates are also provided to allow interaction with other
 types.</p>
 <p><a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>
 started the library and contributed the arithmetic operators in <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>.<br>
 <a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>
 contributed the <a href="#deref and helpers">dereference operators and iterator
 helpers</a> in <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>.<br>
 <a href="http://www.boost.org/people/aleksey_gurtovoy.htm">Aleksey Gurtovoy</a>
 contributed the code to support <a href="#chaining">base class chaining</a>
 while remaining backward-compatible with old versions of the library.<br>
 <a href="http://www.boost.org/people/beman_dawes.html">Beman Dawes</a>
 contributed <a href="http://www.boost.org/libs/utility/operators_test.cpp">test_operators.cpp</a>.</p>
 <h2>Rationale</h2>
 <p>Overloaded operators for class types typically occur in groups. If you can
 write <code>x + y</code>, you probably also want to be able to write <code>x +=
 y</code>. If you can write <code>x &lt; y,</code> you also want <code>x &gt; y,
 x &gt;= y,</code> and <code>x &lt;= y</code>. Moreover, unless your class has
 really surprising behavior, some of these related operators can be defined in
 terms of others (e.g. <code>x &gt;= y <b>&lt;=&gt;</b> !(x &lt; y)</code>).
 Replicating this boilerplate for multiple classes is both tedious and
 error-prone. The <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>
 templates help by generating operators for you at namespace scope based on other
 operators you've defined in your class.</p>
 <a name="two_arg">
 <h2>Two-Argument Template Forms</h2>
 </a>
 <p>The arguments to a binary operator commonly have identical types, but it is
 not unusual to want to define operators which combine different types. For <a href="#usage">example</a>,
 one might want to multiply a mathematical vector by a scalar. The two-argument
 template forms of the arithmetic operator templates are supplied for this
 purpose. When applying the two-argument form of a template, the desired return
 type of the operators typically determines which of the two types in question
 should be derived from the operator template. For example, if the result of <code>T&nbsp;+&nbsp;U</code>
 is of type <code>T</code>, then <code>T</code> (not <code>U</code>) should be
 derived from <code>addable&lt;T,U&gt;</code>. The comparison templates <code><a href="#less_than_comparable">less_than_comparable&lt;&gt;</a></code>
 and <code><a href="#equality_comparable">equality_comparable&lt;&gt;</a></code>
 are exceptions to this guideline, since the return type of the operators they
 define is <code>bool</code>.</p>
 <p>On compilers which do not support partial specialization, the two-argument
 forms must be specified by using the names shown below with the trailing <code>'2'</code>.
 The single-argument forms with the trailing <code>'1'</code> are provided for
 symmetry and to enable certain applications of the <a href="#chaining">base
 class chaining</a> technique.</p>
 <h2>Arithmetic operators table</h2>
 <p>The requirements for the types used to instantiate operator templates are
 specified in terms of expressions which must be valid and by the return type of
 the expression. In the following table <code>t</code> and <code>t1</code> are
 values of type <code>T</code>, and <code>u</code> is a value of type <code>U</code>.
 Every template in the library other than <a href="#operators"><code>operators&lt;&gt;</code></a>
 and <a href="#operators"><code>operators2&lt;&gt;</code></a> has an additional
 optional template parameter <code>B</code> which is not shown in the table, but
 is explained <a href="#chaining">below</a></p>
 <table cellpadding="5" border="1">
  <tbody>
    <tr>
      <td><b>template</b></td>
      <td><b>template will supply</b></td>
      <td><b>Requirements</b></td>
    </tr>
    <a name="operators">
    <tr>
      <td><code>operators&lt;T&gt;</code></td>
      <td>All the other &lt;T&gt; templates in this table.</td>
      <td>All the &lt;T&gt; requirements in this table.</td>
    <tr>
      <td><code>operators&lt;T,U&gt;<br>
        operators2&lt;T,U&gt;</code></td>
      <td>All the other &lt;T,U&gt; templates in this table, plus incrementable&lt;T&gt;
        and decrementable&lt;T&gt;.</td>
      <td><b>All</b> the &lt;T,U&gt; requirements in this table</a><a href="#portability">*</a>,
      plus incrementable&lt;T&gt; and decrementable&lt;T&gt;.</td>
    </tr>
    <a name="less_than_comparable">
    <tr>
      <td><code>less_than_comparable&lt;T&gt;<br>
        less_than_comparable1&lt;T&gt;</code></td>
      <td><code>bool operator&gt;(const T&amp;, const T&amp;)&nbsp;<br>
        bool operator&lt;=(const T&amp;, const T&amp;)<br>
        bool operator&gt;=(const T&amp;, const T&amp;)</code></td>
      <td><code>t&lt;t1</code>. Return convertible to bool</td>
    <tr>
      <td><code>less_than_comparable&lt;T,U&gt;<br>
        less_than_comparable2&lt;T,U&gt;</code></td>
      <td><code>bool operator&lt;=(const T&amp;, const U&amp;)<br>
        bool operator&gt;=(const T&amp;, const U&amp;)<br>
        bool operator&gt;(const U&amp;, const T&amp;)&nbsp;<br>
        bool operator&lt;(const U&amp;, const T&amp;)&nbsp;<br>
        bool operator&lt;=(const U&amp;, const T&amp;)<br>
        bool operator&gt;=(const U&amp;, const T&amp;)</code></td>
      <td><code>t&lt;u</code>. Return convertible to bool<br>
        <code>t&gt;u</code>. Return convertible to bool</td>
    </tr>
    </a><a name="equality_comparable">
    <tr>
      <td><code>equality_comparable&lt;T&gt;<br>
        equality_comparable1&lt;T&gt;</code></td>
      <td><code>bool operator!=(const T&amp;, const T&amp;)</code></td>
      <td><code>t==t1</code>. Return convertible to bool</td>
    <tr>
      <td><code>equality_comparable&lt;T,U&gt;<br>
        equality_comparable2&lt;T,U&gt;</code></td>
      <td><code>friend bool operator==(const U&amp;, const T&amp;)<br>
        friend bool operator!=(const U&amp;, const T&amp;)<br>
        friend bool operator!=( const T&amp;, const U&amp;)</code></td>
      <td><code>t==u</code>. Return convertible to bool</td>
    </tr>
    </a>
    <tr>
      <td><code>addable&lt;T&gt;<br>
        addable1&lt;T&gt;</code></td>
      <td><code>T operator+(T, const T&amp;)</code></td>
      <td><code>t+=t1</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>addable&lt;T,U&gt;<br>
        addable2&lt;T,U&gt;</code></td>
      <td><code>T operator+(T, const U&amp;)<br>
        T operator+(const U&amp;, T )</code></td>
      <td><code>t+=u</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>subtractable&lt;T&gt;<br>
        subtractable1&lt;T&gt;</code></td>
      <td><code>T operator-(T, const T&amp;)</code></td>
      <td><code>t-=t1</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>subtractable&lt;T,U&gt;<br>
        subtractable2&lt;T,U&gt;</code></td>
      <td><code>T operator-(T, const U&amp;)</code></td>
      <td><code>t-=u</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>multipliable&lt;T&gt;<br>
        multipliable1&lt;T&gt;</code></td>
      <td><code>T operator*(T, const T&amp;)</code></td>
      <td><code>t*=t1</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>multipliable&lt;T,U&gt;<br>
        multipliable2&lt;T,U&gt;</code></td>
      <td><code>T operator*(T, const U&amp;)<br>
        T operator*(const U&amp;, T )</code></td>
      <td><code>t*=u</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>dividable&lt;T&gt;<br>
        dividable1&lt;T&gt;</code></td>
      <td><code>T operator/(T, const T&amp;)</code></td>
      <td><code>t/=t1</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>dividable&lt;T,U&gt;<br>
        dividable2&lt;T,U&gt;</code></td>
      <td><code>T operator/(T, const U&amp;)</code></td>
      <td><code>t/=u</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>modable&lt;T&gt;<br>
        modable1&lt;T&gt;</code></td>
      <td><code>T operator%(T, const T&amp;)</code></td>
      <td><code>t%=t1</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>modable&lt;T,U&gt;<br>
        modable2&lt;T,U&gt;</code></td>
      <td><code>T operator%(T, const U&amp;)</code></td>
      <td><code>t%=u</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>orable&lt;T&gt;<br>
        orable1&lt;T&gt;</code></td>
      <td><code>T operator|(T, const T&amp;)</code></td>
      <td><code>t|=t1</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>orable&lt;T,U&gt;<br>
        orable2&lt;T,U&gt;</code></td>
      <td><code>T operator|(T, const U&amp;)<br>
        T operator|(const U&amp;, T )</code></td>
      <td><code>t|=u</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>andable&lt;T&gt;<br>
        andable1&lt;T&gt;</code></td>
      <td><code>T operator&amp;(T, const T&amp;)</code></td>
      <td><code>t&amp;=t1</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>andable&lt;T,U&gt;<br>
        andable2&lt;T,U&gt;</code></td>
      <td><code>T operator&amp;(T, const U&amp;)<br>
        T operator&amp;(const U&amp;, T)</code></td>
      <td><code>t&amp;=u</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>xorable&lt;T&gt;<br>
        xorable1&lt;T&gt;</code></td>
      <td><code>T operator^(T, const T&amp;)</code></td>
      <td><code>t^=t1</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>xorable&lt;T,U&gt;<br>
        xorable2&lt;T,U&gt;</code></td>
      <td><code>T operator^(T, const U&amp;)<br>
        T operator^(const U&amp;, T )</code></td>
      <td><code>t^=u</code>. Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>incrementable&lt;T&gt;<br>
        incrementable1&lt;T&gt;</code></td>
      <td><code>T operator++(T&amp; x, int)</code></td>
      <td><code>T temp(x); ++x; return temp;</code><br>
        Return convertible to <code>T</code></td>
    </tr>
    <tr>
      <td><code>decrementable&lt;T&gt;<br>
        decrementable1&lt;T&gt;</code></td>
      <td><code>T operator--(T&amp; x, int)</code></td>
      <td><code>T temp(x); --x; return temp;</code><br>
        Return convertible to <code>T</code></td>
    </tr>
  </tbody>
 </table>
 <br>
 <b><a name="portability">Portability Note:</a></b> many compilers (e.g. MSVC6.3,
 GCC 2.95.2) will not enforce the requirements in this table unless the
 operations which depend on them are actually used. This is not
 standard-conforming behavior. If you are trying to write portable code it is
 important not to rely on this bug. In particular, it would be convenient to
 derive all your classes which need binary operators from the <a href="#operators"><code>operators&lt;&gt;</code></a>
 and <a href="#operators"><code>operators2&lt;&gt;</code></a> templates,
 regardless of whether they implement all the requirements in the table. Even if
 this works with your compiler today, it may not work tomorrow.
 <h2><a name="chaining">Base Class Chaining</a> and Object Size</h2>
 <p>Every template listed in the table except <a href="#operators"><code>operators&lt;&gt;</code></a>
 and <a href="#operators"><code>operators2&lt;&gt;</code></a> has an additional
 optional template parameter <code>B</code>.&nbsp; If supplied, <code>B</code>
 must be a class type; the resulting class will be publicly derived from B. This
 can be used to avoid the object size bloat commonly associated with multiple
 empty base classes (see the <a href="#old_lib_note">note for users of older
 versions</a> below for more details). To provide support for several groups of
 operators, use the additional parameter to chain operator templates into a
 single-base class hierarchy, as in the following <a href="#usage">example</a>.</p>
 <p><b>Caveat:</b> to chain to a base class which is <i>not</i> a boost operator
 template when using the <a href="#two_arg">single-argument form</a><a> of a
 boost operator template, you must specify the operator template with the
 trailing <code>'1'</code> in its name. Otherwise the library will assume you
 mean to define a binary operation combining the class you intend to use as a
 base class and the class you're deriving.</p>
 <p><b>Borland users</b>: even single-inheritance seems to cause an increase in
 object size in some cases. If you are not defining a template, you may get
 better object-size performance by avoiding derivation altogether, and instead
 explicitly instantiating the operator template as follows:
 <pre>
    class myclass // lose the inheritance...
    {
        //...
    };
    // explicitly instantiate the operators I need.
    template class less_than_comparable&lt;myclass&gt;;
    template class equality_comparable&lt;myclass&gt;;
    template class incrementable&lt;myclass&gt;;
    template class decrementable&lt;myclass&gt;;
    template class addable&lt;myclass,long&gt;;
    template class subtractable&lt;myclass,long&gt;;
 </pre>
 </a><a name="usage">
 <h2>Usage example</h2>
 </a>
 <pre>template &lt;class T&gt;
 class point    // note: private inheritance is OK here!
    : boost::addable&lt; point&lt;T&gt;          // point + point
    , boost::subtractable&lt; point&lt;T&gt;     // point - point
    , boost::dividable2&lt; point&lt;T&gt;, T    // point / T
    , boost::multipliable2&lt; point&lt;T&gt;, T // point * T, T * point
      &gt; &gt; &gt; &gt;
 {
 public:
    point(T, T);
    T x() const;
    T y() const;
    point operator+=(const point&amp;);
    // point operator+(point, const point&amp;) automatically
    // generated by addable.
    point operator-=(const point&amp;);
    // point operator-(point, const point&amp;) automatically
    // generated by subtractable.
    point operator*=(T);
    // point operator*(point, const T&amp;) and
    // point operator*(const T&amp;, point) auto-generated
    // by multipliable.
    point operator/=(T);
    // point operator/(point, const T&amp;) auto-generated
    // by dividable.
 private:
    T x_;
    T y_;
 };
 // now use the point&lt;&gt; class:
 template &lt;class T&gt;
 T length(const point&lt;T&gt; p)
 {
    return sqrt(p.x()*p.x() + p.y()*p.y());
 }
 const point&lt;float&gt; right(0, 1);
 const point&lt;float&gt; up(1, 0);
 const point&lt;float&gt; pi_over_4 = up + right;
 const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);</pre>
 <h2>Arithmetic operators demonstration and test program</h2>
 <p>The <a href="http://www.boost.org/libs/utility/operators_test.cpp">operators_test.cpp</a>
 program demonstrates the use of the arithmetic operator templates, and can also
 be used to verify correct operation.</p>
 <p>The test program has been compiled and run successfully with:&nbsp;</p>
 <ul>
  <li>GCC 2.95.2
  <li>GCC 2.95.2 / STLport 4.0b8.
  <li>Metrowerks Codewarrior 5.3
  <li>KAI C++ 3.3
  <li>Microsoft Visual C++ 6.0 SP3.
  <li>Microsoft Visual C++ 6.0 SP3 / STLport 4.0b8.</li>
 </ul>
 <h1><a name="deref and helpers">Dereference</a> operators and iterator helpers</h1>
 <p>The <a href="#Iterator helpers">iterator helper</a> templates ease the task
 of creating a custom iterator. Similar to arithmetic types, a complete iterator
 has many operators that are &quot;redundant&quot; and can be implemented in
 terms of the core set of operators.</p>
 <p>The <a href="#dereference">dereference operators</a> were motivated by the <a href="#Iterator helpers">iterator
 helpers</a>, but are often useful in non-iterator contexts as well. Many of the
 redundant iterator operators are also arithmetic operators, so the iterator
 helper classes borrow many of the operators defined above. In fact, only two new
 operators need to be defined! (the pointer-to-member <code>operator-&gt;</code>
 and the subscript <code>operator[]</code>). </PP>
 <h3>Notation</h3>
 <table>
  <tbody>
    <tr>
      <td valign="top"><code>T</code></td>
      <td valign="top">is the user-defined type for which the operations are
        being supplied.</td>
    </tr>
    <tr>
      <td valign="top"><code>V</code></td>
      <td valign="top">is the type which the resulting <code>dereferenceable</code>
        type &quot;points to&quot;, or the <code>value_type</code> of the custom
        iterator.</td>
    </tr>
    <tr>
      <td valign="top"><code>D</code></td>
      <td valign="top">is the type used to index the resulting <code>indexable</code>
        type or the <code>difference_type</code> of the custom iterator.</td>
    </tr>
    <tr>
      <td valign="top"><code>P</code></td>
      <td valign="top">is a type which can be dereferenced to access <code>V</code>,
        or the <code>pointer</code> type of the custom iterator.</td>
    </tr>
    <tr>
      <td valign="top"><code>R</code></td>
      <td valign="top">is the type returned by indexing the <code>indexable</code>
        type or the <code>reference</code> type of the custom iterator.</td>
    </tr>
    <tr>
      <td valign="top"><code>i</code></td>
      <td valign="top">is short for <code>static_cast&lt;const T&amp;&gt;(*this)</code>,
        where <code>this</code> is a pointer to the helper class.<br>
        Another words, <code>i</code> should be an object of the custom iterator
        type.</td>
    </tr>
    <tr>
      <td valign="top"><code>x,x1,x2</code></td>
      <td valign="top">are objects of type <code>T</code>.</td>
    </tr>
    <tr>
      <td valign="top"><code>n</code></td>
      <td valign="top">is an object of type <code>D</code>.</td>
    </tr>
  </tbody>
 </table>
 <p>The requirements for the types used to instantiate the dereference operators
 and iterator helpers are specified in terms of expressions which must be valid
 and their return type.&nbsp;</p>
 <h2><a name="dereference">Dereference operators</a></h2>
 <p>The dereference operator templates in this table all accept an optional
 template parameter (not shown) to be used for <a href="#chaining">base class
 chaining</a>.
 <table cellpadding="5" border="1">
  <tbody>
    <tr>
      <td><b>template</b></td>
      <td><b>template will supply</b></td>
      <td><b>Requirements</b></td>
    </tr>
    <tr>
      <td><code>dereferenceable&lt;T,P&gt;</code></td>
      <td><code>P operator-&gt;() const</code></td>
      <td><code>(&amp;*i.)</code>. Return convertible to <code>P</code>.</td>
    </tr>
    <tr>
      <td><code>indexable&lt;T,D,R&gt;</code></td>
      <td><code>R operator[](D n) const</code></td>
      <td><code>*(i + n)</code>. Return of type <code>R</code>.</td>
    </tr>
  </tbody>
 </table>
 <h2><a name="Iterator helpers">Iterator</a> helpers</h2>
 <p>There are three separate iterator helper classes, each for a different
 category of iterator. Here is a summary of the core set of operators that the
 custom iterator must define, and the extra operators that are created by the
 helper classes. For convenience, the helper classes also fill in all of the
 typedef's required of iterators by the C++ standard (<code>iterator_category</code>,
 <code>value_type</code>, etc.).</p>
 <table cellpadding="5" border="1" valign="top">
  <tbody>
    <tr>
      <td><b>template</b></td>
      <td><b>template will supply</b></td>
      <td><b>Requirements</b></td>
    </tr>
    <tr>
      <td><code>forward_iterator_helper</code><br>
        <code>&lt;T,V,D,P,R&gt;</code></td>
      <td><code>bool operator!=(const T&amp; x1, const T&amp; x2)</code><br>
        <code>T operator++(T&amp; x, int)</code><br>
        <code>V* operator-&gt;() const</code><br>
      </td>
      <td><code>x1==x2</code>. Return convertible to bool<br>
        <code>T temp(x); ++x; return temp;</code><br>
        <code>(&amp;*i.)</code>. Return convertible to <code>V*</code>.</td>
    </tr>
    <tr>
      <td><code>bidirectional_iterator_helper</code><br>
        <code>&lt;T,V,D,P,R&gt;</code></td>
      <td>Same as above, plus<br>
        <code>T operator--(T&amp; x, int)</code></td>
      <td>Same as above, plus<br>
        <code>T temp(x); --x; return temp;</code></td>
    </tr>
    <tr>
      <td><code>random_access_iterator_helper</code><br>
        <code>&lt;T,V,D,P,R&gt;</code></td>
      <td>Same as above, plus<br>
        <code>T operator+(T x, const D&amp;)<br>
        T operator+(const D&amp; n, T x)<br>
        T operator-(T x, const D&amp; n)<br>
        R operator[](D n) const<br>
        bool operator&gt;(const T&amp; x1, const T&amp; x2)&nbsp;<br>
        bool operator&lt;=(const T&amp; x1, const T&amp; x2)<br>
        bool operator&gt;=(const T&amp; x1, const T&amp; x2)</code></td>
      <td>Same as above, plus<br>
        <code>x+=n</code>. Return convertible to <code>T</code><br>
        <code>x-=n</code>. Return convertible to <code>T</code><br>
        <code>x1&lt;x2</code>. Return convertible to bool<br>
        And to satisfy <a href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html">RandomAccessIterator</a>:<br>
        <code>x1-x2</code>. Return convertible to <code>D</code></td>
    </tr>
  </tbody>
 </table>
 <h2>Iterator demonstration and test program</h2>
 <p>The <a href="http://www.boost.org/libs/utility/iterators_test.cpp">iterators_test.cpp</a>
 program demonstrates the use of the iterator templates, and can also be used to
 verify correct operation. The following is the custom iterator defined in the
 test program. It demonstrates a correct (though trivial) implementation of the
 core operations that must be defined in order for the iterator helpers to
 &quot;fill in&quot; the rest of the iterator operations.</p>
 <blockquote>
  <pre>template &lt;class T, class R, class P&gt;
 struct test_iter
  : public boost::random_access_iterator_helper&lt;
     test_iter&lt;T,R,P&gt;, T, std::ptrdiff_t, P, R&gt;
 {
  typedef test_iter self;
  typedef R Reference;
  typedef std::ptrdiff_t Distance;
 public:
  test_iter(T* i) : _i(i) { }
  test_iter(const self&amp; x) : _i(x._i) { }
  self&amp; operator=(const self&amp; x) { _i = x._i; return *this; }
  Reference operator*() const { return *_i; }
  self&amp; operator++() { ++_i; return *this; }
  self&amp; operator--() { --_i; return *this; }
  self&amp; operator+=(Distance n) { _i += n; return *this; }
  self&amp; operator-=(Distance n) { _i -= n; return *this; }
  bool operator==(const self&amp; x) const { return _i == x._i; }
  bool operator&lt;(const self&amp; x) const { return _i &lt; x._i; }
  friend Distance operator-(const self&amp; x, const self&amp; y) {
    return x._i - y._i; 
  }
 protected:
  T* _i;
 };</pre>
 </blockquote>
 <p>It has been compiled and run successfully with:</p>
 <ul>
  <li>GCC 2.95.2
  <li>Metrowerks Codewarrior 5.2
  <li>Microsoft Visual C++ 6.0 SP3</li>
 </ul>
 <p><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>
 contributed the iterator operators and helpers.&nbsp; He also contributed <a href="http://www.boost.org/libs/utility/iterators_test.cpp">iterators_test.cpp</a>.&nbsp;</p>
 <hr>
 <h2><a name="old_lib_note">Note for users of older versions</a></h2>
 <p>The <a href="#chaining">changes in the library interface and recommended
 usage</a> were motivated by some practical issues described below. The new
 version of the library is still backward-compatible with the former one (so
 you're not <i>forced</i> change any existing code), but the old usage is
 deprecated. Though it was arguably simpler and more intuitive than using <a href="#chaining">base
 class chaining</a>, it has been discovered that the old practice of deriving
 from multiple operator templates can cause the resulting classes to be much
 larger than they should be. Most modern C++ compilers significantly bloat the
 size of classes derived from multiple empty base classes, even though the base
 classes themselves have no state. For instance, the size of <code>point&lt;int&gt;</code>
 from the <a href="#usage">example</a> above was 12-24 bytes on various compilers
 for the Win32 platform, instead of the expected 8 bytes.
 <p>Strictly speaking, it was not the library's fault - the language rules allow
 the compiler to apply the empty base class optimization in that situation. In
 principle an arbitrary number of empty base classes can be allocated at the same
 offset, provided that none of them have a common ancestor (see section 10.5 [class.derived],
 par. 5 of the standard). But the language definition also doesn't <i>require</i>
 implementations to do the optimization, and few if any of today's compilers
 implement it when multiple inheritance is involved. What's worse, it is very
 unlikely that implementors will adopt it as a future enhancement to existing
 compilers, because it would break binary compatibility between code generated by
 two different versions of the same compiler. As Matt Austern said, &quot;One of
 the few times when you have the freedom to do this sort of thing is when you're
 targeting a new architecture...&quot;. On the other hand, many common compilers
 will use the empty base optimization for single inheritance hierarchies.</p>
 <p>Given the importance of the issue for the users of the library (which aims to
 be useful for writing light-weight classes like <code>MyInt</code> or <code>point&lt;&gt;</code>),
 and the forces described above, we decided to change the library interface so
 that the object size bloat could be eliminated even on compilers that support
 only the simplest form of the empty base class optimization. The current library
 interface is the result of those changes. Though the new usage is a bit more
 complicated than the old one, we think it's worth it to make the library more
 useful in real world. Alexy Gurtovoy contributed the code which supports the new
 usage idiom while allowing the library remain backward-compatible.</p>
 <hr>
 <p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->03 Aug 2000<!--webbot bot="Timestamp" endspan i-checksum="14750" -->
 </p>
 <p><EFBFBD> Copyright David Abrahams and Beman Dawes 1999-2000. Permission to copy,
 use, modify, sell and distribute this document is granted provided this
 copyright notice appears in all copies. This document is provided &quot;as
 is&quot; without express or implied warranty, and with no claim as to its
 suitability for any purpose.</p>
 </body>
 </html>
--- a/tie.html
+++ b/tie.html
@ -1,138 +0,0 @@
 <HTML>
 <!--
  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine  2000
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  We make no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  -->
 <Head>
 <Title>Boost Tie</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
 	ALINK="#ff0000"> 
 <IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost"> 
 <BR Clear>
 <H1><A NAME="sec:tie"></A>
 <TT>tie</TT>
 </H1>
 <P>
 <PRE>
 template &lt;class A, class B&gt;
 tied&lt;A,B&gt; tie(A&amp; a, B&amp; b);
 </PRE>
 <P>
 This is a utility function that makes it more convenient to work with
 a function which returns a pair. The effect of the <TT>tie()</TT>
 function is to allow the assignment of the two values of the pair to
 two separate variables. The idea for this comes from Jaakko
 J&#228;rvi's Binders&nbsp;[<A
 HREF="bibliography.html#jaakko_tuple_assign">1</A>].
 <P>
 <H3>Where Defined</H3>
 <P>
 <a href="../../boost/utility.hpp"><TT>boost/utility.hpp</TT></a>
 <P>
 <H3>Example</H3>
 <P>
 An example of using the <TT>tie()</TT> function with the
 <TT>vertices()</TT> function, which returns a pair of
 type <TT>std::pair&lt;vertex_iterator,vertex_iterator&gt;</TT>.  The
 pair of iterators is assigned to the iterator variables <TT>i</TT> and
 <TT>end</TT>.
 <P>
 <PRE>
  graph_traits&lt; adjacency_list&lt;&gt; &gt;::vertex_iterator i, end;
  for(tie(i,end) = vertices(G); i != end; ++i)
    // ...
 </PRE>
 <P>
 Here is another example that uses <TT>tie()</TT> for handling
 operaitons with <a
 href="http://www.sgi.com/Technology/STL/set.html"><TT>std::set</TT></a>.
 <P>
 <PRE>
 #include &lt;set&gt;
 #include &lt;algorithm&gt;
 #include &lt;iostream&gt;
 #include &lt;boost/utility.hpp&gt;
 int
 main(int, char*[])
 {
  {
    typedef std::set&lt;int&gt; SetT;
    SetT::iterator i, end;
    bool inserted;
    int vals[5] = { 5, 2, 4, 9, 1 };
    SetT s(vals, vals + 5);
    // Using tie() with a return value of pair&lt;iterator,bool&gt;
    int new_vals[2] = { 3, 9 };
    for (int k = 0; k &lt; 2; ++k) {
      boost::tie(i,inserted) = s.insert(new_vals[k]);
      if (!inserted)
        std::cout &lt;&lt; *i &lt;&lt; " was already in the set." &lt;&lt; std::endl;
      else
        std::cout &lt;&lt; *i &lt;&lt; " successfully inserted." &lt;&lt; std::endl;    
    }
  }    
  {
    int* i, *end;
    int vals[6] = { 5, 2, 4, 4, 9, 1 };
    std::sort(vals, vals + 6);
    // Using tie() with a return value of pair&lt;iterator,iterator&gt;
    boost::tie(i,end) = std::equal_range(vals, vals + 6, 4);
    std::cout &lt;&lt; "There were " &lt;&lt; std::distance(i,end)
              &lt;&lt; " occurances of " &lt;&lt; *i &lt;&lt; "." &lt;&lt; std::endl;
    // Footnote: of course one would normally just use std::count()
    // to get this information, but that would spoil the example :)
  }
  return 0;
 }
 </PRE>
 The output is:
 <PRE>
  3 successfully inserted.
  9 was already in the set.
  There were 2 occurances of 4.
 </PRE>
 <br>
 <HR>
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy 2000</TD><TD>
 <A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
 Univ.of Notre Dame (<A
 HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
 <A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
 <A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
 Univ.of Notre Dame (<A
 HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
 </TD></TR></TABLE>
 </BODY>
 </HTML> 
--- a/tie_example.cpp
+++ b/tie_example.cpp
@ -1,61 +0,0 @@
 //  (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
 //  sell and distribute this software is granted provided this
 //  copyright notice appears in all copies. This software is provided
 //  "as is" without express or implied warranty, and with no claim as
 //  to its suitability for any purpose.
 //
 // This is an example demonstrating how to use the tie() function.
 // The purpose of tie() is to make it easiery to deal with std::pair
 // return values.
 //
 // Contributed by Jeremy Siek
 //
 // Sample output
 //
 // 3 successfully inserted.
 // 9 was already in the set.
 // There were 2 occurances of 4.
 #include <set>
 #include <algorithm>
 #include <iostream>
 #include <boost/utility.hpp>
 int
 main(int, char*[])
 {
  {
    typedef std::set<int> SetT;
    SetT::iterator i, end;
    bool inserted;
    int vals[5] = { 5, 2, 4, 9, 1 };
    SetT s(vals, vals + 5);
    // Using tie() with a return value of pair<iterator,bool>
    int new_vals[2] = { 3, 9 };
    for (int k = 0; k < 2; ++k) {
      boost::tie(i,inserted) = s.insert(new_vals[k]);
      if (!inserted)
 	std::cout << *i << " was already in the set." << std::endl;
      else
 	std::cout << *i << " successfully inserted." << std::endl;    
    }
  }    
  {
    int* i, *end;
    int vals[6] = { 5, 2, 4, 4, 9, 1 };
    std::sort(vals, vals + 6);
    // Using tie() with a return value of pair<iterator,iterator>
    boost::tie(i,end) = std::equal_range(vals, vals + 6, 4);
    std::cout << "There were " << std::distance(i,end)
 	      << " occurances of " << *i << "." << std::endl;
    // Footnote: of course one would normally just use std::count()
    // to get this information, but that would spoil the example :)
  }
  return 0;
 }
--- a/type_traits.htm
+++ b/type_traits.htm
@ -1,626 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type"
 content="text/html; charset=iso-8859-1">
 <meta name="Template"
 content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
 <meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
 <title>Type Traits</title>
 </head>
 <body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
 <h1><img src="../../c++boost.gif" width="276" height="86">Header
 &lt;<a href="../../boost/detail/type_traits.hpp">boost/type_traits.hpp</a>&gt;</h1>
 <p>The contents of &lt;boost/type_traits.hpp&gt; are declared in
 namespace boost.</p>
 <p>The file &lt;<a href="../../boost/detail/type_traits.hpp">boost/type_traits.hpp</a>&gt;
 contains various template classes that describe the fundamental
 properties of a type; each class represents a single type
 property or a single type transformation. This documentation is
 divided up into the following sections:</p>
 <pre><a href="#fop">Fundamental type operations</a>
 <a href="#fp">Fundamental type properties</a>
   <a href="#misc">Miscellaneous</a>
 <code>   </code><a href="#cv">cv-Qualifiers</a>
 <code>   </code><a href="#ft">Fundamental Types</a>
 <code>   </code><a href="#ct">Compound Types</a>
 <code>   </code><a href="#ot">Object/Scalar Types</a>
 <a href="#cs">Compiler Support Information</a>
 <a href="#ec">Example Code</a></pre>
 <h2><a name="fop"></a>Fundamental type operations</h2>
 <p>Usage: &quot;class_name&lt;T&gt;::type&quot; performs
 indicated transformation on type T.</p>
 <table border="1" cellpadding="7" cellspacing="1" width="100%">
    <tr>
        <td valign="top" width="45%"><p align="center">Expression.</p>
        </td>
        <td valign="top" width="45%"><p align="center">Description.</p>
        </td>
        <td valign="top" width="33%"><p align="center">Compiler.</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>remove_volatile&lt;T&gt;::type</code></td>
        <td valign="top" width="45%">Creates a type the same as T
        but with any top level volatile qualifier removed. For
        example &quot;volatile int&quot; would become &quot;int&quot;.</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>remove_const&lt;T&gt;::type</code></td>
        <td valign="top" width="45%">Creates a type the same as T
        but with any top level const qualifier removed. For
        example &quot;const int&quot; would become &quot;int&quot;.</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>remove_cv&lt;T&gt;::type</code></td>
        <td valign="top" width="45%">Creates a type the same as T
        but with any top level cv-qualifiers removed. For example
        &quot;const int&quot; would become &quot;int&quot;, and
        &quot;volatile double&quot; would become &quot;double&quot;.</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>remove_reference&lt;T&gt;::type</code></td>
        <td valign="top" width="45%">If T is a reference type
        then removes the reference, otherwise leaves T unchanged.
        For example &quot;int&amp;&quot; becomes &quot;int&quot;
        but &quot;int*&quot; remains unchanged.</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>add_reference&lt;T&gt;::type</code></td>
        <td valign="top" width="45%">If T is a reference type
        then leaves T unchanged, otherwise converts T to a
        reference type. For example &quot;int&amp;&quot; remains
        unchanged, but &quot;double&quot; becomes &quot;double&amp;&quot;.</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>remove_bounds&lt;T&gt;::type</code></td>
        <td valign="top" width="45%">If T is an array type then
        removes the top level array qualifier from T, otherwise
        leaves T unchanged. For example &quot;int[2][3]&quot;
        becomes &quot;int[3]&quot;.</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <h2><a name="fp"></a>Fundamental type properties</h2>
 <p>Usage: &quot;class_name&lt;T&gt;::value&quot; is true if
 indicated property is true, false otherwise. (Note that class_name&lt;T&gt;::value
 is always defined as a compile time constant).</p>
 <h3><a name="misc"></a>Miscellaneous</h3>
 <table border="1" cellspacing="1" width="100%">
    <tr>
        <td width="37%"><p align="center">Expression</p>
        </td>
        <td width="36%"><p align="center">Description</p>
        </td>
        <td width="27%"><p align="center">Compiler</p>
        </td>
    </tr>
    <tr>
        <td width="37%"><div align="center"><center><pre><code>is_same&lt;T,U&gt;::value</code></pre>
        </center></div></td>
        <td width="36%"><p align="center">True if T and U are the
        same type.</p>
        </td>
        <td width="27%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td width="37%"><div align="center"><center><pre>is_convertible&lt;T,U&gt;::value</pre>
        </center></div></td>
        <td width="36%"><p align="center">True if type T is
        convertible to type U.</p>
        </td>
        <td width="27%">&nbsp;</td>
    </tr>
    <tr>
        <td width="37%"><div align="center"><center><pre>alignment_of&lt;T&gt;::value</pre>
        </center></div></td>
        <td width="36%"><p align="center">An integral value
        representing the minimum alignment requirements of type T
        (strictly speaking defines a multiple of the type's
        alignment requirement; for all compilers tested so far
        however it does return the actual alignment).</p>
        </td>
        <td width="27%">&nbsp;</td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <h3><a name="cv"></a>cv-Qualifiers</h3>
 <p>The following classes determine what cv-qualifiers are present
 on a type (see 3.93).</p>
 <table border="1" cellpadding="7" cellspacing="1" width="100%">
    <tr>
        <td valign="top" width="37%"><p align="center">Expression.</p>
        </td>
        <td valign="top" width="37%"><p align="center">Description.</p>
        </td>
        <td valign="top" width="27%"><p align="center">Compiler.</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="37%"><code>is_const&lt;T&gt;::value</code></td>
        <td valign="top" width="37%">True if type T is top-level
        const qualified.</td>
        <td valign="top" width="27%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="37%"><code>is_volatile&lt;T&gt;::value</code></td>
        <td valign="top" width="37%">True if type T is top-level
        volatile qualified.</td>
        <td valign="top" width="27%"><p align="center">P</p>
        </td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <h3><a name="ft"></a>Fundamental Types</h3>
 <p>The following will only ever be true for cv-unqualified types;
 these are closely based on the section 3.9 of the C++ Standard.</p>
 <table border="1" cellpadding="7" cellspacing="1" width="100%">
    <tr>
        <td valign="top" width="45%"><p align="center">Expression.</p>
        </td>
        <td valign="top" width="45%"><p align="center">Description.</p>
        </td>
        <td valign="top" width="33%"><p align="center">Compiler.</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_void&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True only if T is void.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_standard_unsigned_integral&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True only if T is one of the
        standard unsigned integral types (3.9.1 p3) - unsigned
        char, unsigned short, unsigned int, and unsigned long.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_standard_signed_integral&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True only if T is one of the
        standard signed integral types (3.9.1 p2) - signed char,
        short, int, and long.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_standard_integral&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a standard
        integral type(3.9.1 p7) - T is either char, wchar_t, bool
        or either is_standard_signed_integral&lt;T&gt;::value or
        is_standard_integral&lt;T&gt;::value is true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_standard_float&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is one of the
        standard floating point types(3.9.1 p8) - float, double
        or long double.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_standard_arithmetic&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a standard
        arithmetic type(3.9.1 p8) - implies is_standard_integral
        or is_standard_float is true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_standard_fundamental&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a standard
        arithmetic type or if T is void.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_extension_unsigned_integral&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True for compiler specific
        unsigned integral types.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_extension_signed_integral&lt;T&gt;&gt;:value</code></td>
        <td valign="top" width="45%">True for compiler specific
        signed integral types.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_extension_integral&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if either is_extension_unsigned_integral&lt;T&gt;::value
        or is_extension_signed_integral&lt;T&gt;::value is true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_extension_float&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True for compiler specific
        floating point types.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_extension_arithmetic&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if either is_extension_integral&lt;T&gt;::value
        or is_extension_float&lt;T&gt;::value are true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>&nbsp;is_extension_fundamental&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if either is_extension_arithmetic&lt;T&gt;::value
        or is_void&lt;T&gt;::value are true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>&nbsp;is_unsigned_integral&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if either is_standard_unsigned_integral&lt;T&gt;::value
        or is_extention_unsigned_integral&lt;T&gt;::value are
        true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_signed_integral&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if either is_standard_signed_integral&lt;T&gt;::value
        or is_extention_signed_integral&lt;T&gt;&gt;::value are
        true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_integral&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if either is_standard_integral&lt;T&gt;::value
        or is_extention_integral&lt;T&gt;::value are true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_float&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if either is_standard_float&lt;T&gt;::value
        or is_extention_float&lt;T&gt;::value are true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_arithmetic&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if either is_integral&lt;T&gt;::value
        or is_float&lt;T&gt;::value are true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_fundamental&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if either is_arithmetic&lt;T&gt;::value
        or is_void&lt;T&gt;::value are true.</td>
        <td valign="top" width="33%">&nbsp;</td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <h3><a name="ct"></a>Compound Types</h3>
 <p>The following will only ever be true for cv-unqualified types,
 as defined by the Standard.&nbsp;</p>
 <table border="1" cellpadding="7" cellspacing="1" width="100%">
    <tr>
        <td valign="top" width="45%"><p align="center">Expression</p>
        </td>
        <td valign="top" width="45%"><p align="center">Description</p>
        </td>
        <td valign="top" width="33%"><p align="center">Compiler</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_array&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is an array type.</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_pointer&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a regular
        pointer type - including function pointers - but
        excluding pointers to member functions (3.9.2 p1 and 8.3.1).</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_member_pointer&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a pointer to a
        non-static class member (3.9.2 p1 and 8.3.1).</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_reference&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a reference
        type (3.9.2 p1 and 8.3.2).</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_class&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a class or
        struct type.</td>
        <td valign="top" width="33%"><p align="center">PD</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_union&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a union type.</td>
        <td valign="top" width="33%"><p align="center">C</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_enum&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is an enumerator
        type.</td>
        <td valign="top" width="33%"><p align="center">C</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_compound&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is any of the
        above compound types.</td>
        <td valign="top" width="33%"><p align="center">PD</p>
        </td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <h3><a name="ot"></a>Object/Scalar Types</h3>
 <p>The following ignore any top level cv-qualifiers: if <code>class_name&lt;T&gt;::value</code>
 is true then <code>class_name&lt;cv-qualified-T&gt;::value</code>
 will also be true.</p>
 <table border="1" cellpadding="7" cellspacing="1" width="100%">
    <tr>
        <td valign="top" width="45%"><p align="center">Expression</p>
        </td>
        <td valign="top" width="45%"><p align="center">Description</p>
        </td>
        <td valign="top" width="33%"><p align="center">Compiler</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_object&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is not a reference
        type, or a (possibly cv-qualified) void type.</td>
        <td valign="top" width="33%"><p align="center">P</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_standard_scalar&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a standard
        arithmetic type, an enumerated type, a pointer or a
        member pointer.</td>
        <td valign="top" width="33%"><p align="center">PD</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_extension_scalar&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is an extentions
        arithmetic type, an enumerated type, a pointer or a
        member pointer.</td>
        <td valign="top" width="33%"><p align="center">PD</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_scalar&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is an arithmetic
        type, an enumerated type, a pointer or a member pointer.</td>
        <td valign="top" width="33%"><p align="center">PD</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_POD&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is a &quot;Plain
        Old Data&quot; type (see 3.9 p2&amp;p3). Note that
        although this requires compiler support to be correct in
        all cases, if T is a scalar or an array of scalars then
        we can correctly define T as a POD.</td>
        <td valign="top" width="33%"><p align="center">PC</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>is_empty&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T is an empty struct
        or class. If the compiler implements the &quot;zero sized
        empty base classes&quot; optimisation, then is_empty will
        correctly guess whether T is empty. Relies upon is_class
        to determine whether T is a class type. Screens out enum
        types by using is_convertible&lt;T,int&gt;, this means
        that empty classes that overload operator int(), will not
        be classified as empty.</td>
        <td valign="top" width="33%"><p align="center">PCD</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>has_trivial_constructor&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T has a trivial
        default constructor - that is T() is equivalent to memset.</td>
        <td valign="top" width="33%"><p align="center">PC</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>has_trivial_copy&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T has a trivial copy
        constructor - that is T(const T&amp;) is equivalent to
        memcpy.</td>
        <td valign="top" width="33%"><p align="center">PC</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>has_trivial_assign&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T has a trivial
        assignment operator - that is if T::operator=(const T&amp;)
        is equivalent to memcpy.</td>
        <td valign="top" width="33%"><p align="center">PC</p>
        </td>
    </tr>
    <tr>
        <td valign="top" width="45%"><code>has_trivial_destructor&lt;T&gt;::value</code></td>
        <td valign="top" width="45%">True if T has a trivial
        destructor - that is if T::~T() has no effect.</td>
        <td valign="top" width="33%"><p align="center">PC</p>
        </td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <h2><a name="cs"></a>Compiler Support Information</h2>
 <p>The legends used in the tables above have the following
 meanings:</p>
 <table border="0" cellpadding="7" cellspacing="0" width="480">
    <tr>
        <td valign="top" width="50%"><p align="center">P</p>
        </td>
        <td valign="top" width="90%">Denotes that the class
        requires support for partial specialisation of class
        templates to work correctly.</td>
    </tr>
    <tr>
        <td valign="top" width="50%"><p align="center">C</p>
        </td>
        <td valign="top" width="90%">Denotes that direct compiler
        support for that traits class is required.</td>
    </tr>
    <tr>
        <td valign="top" width="50%"><p align="center">D</p>
        </td>
        <td valign="top" width="90%">Denotes that the traits
        class is dependent upon a class that requires direct
        compiler support.</td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <p>For those classes that are marked with a D or C, if compiler
 support is not provided, this type trait may return &quot;false&quot;
 when the correct value is actually &quot;true&quot;. The single
 exception to this rule is &quot;is_class&quot;, which attempts to
 guess whether or not T is really a class, and may return &quot;true&quot;
 when the correct value is actually &quot;false&quot;. This can
 happen if: T is a union, T is an enum, or T is a compiler-supplied
 scalar type that is not specialised for in these type traits.</p>
 <p><i>If there is no compiler support</i>, to ensure that these
 traits <i>always</i> return the correct values, specialise 'is_enum'
 for each user-defined enumeration type, 'is_union' for each user-defined
 union type, 'is_empty' for each user-defined empty composite type,
 and 'is_POD' for each user-defined POD type. The 'has_*' traits
 should also be specialized if the user-defined type has those
 traits and is <i>not</i> a POD.</p>
 <p>The following rules are automatically enforced:</p>
 <p>is_enum implies is_POD</p>
 <p>is_POD implies has_*</p>
 <p>This means, for example, if you have an empty POD-struct, just
 specialize is_empty and is_POD, which will cause all the has_* to
 also return true.</p>
 <h2><a name="ec"></a>Example code</h2>
 <p>Type-traits comes with two sample programs: <a
 href="type_traits_test.cpp">type_traits_test.cpp</a> tests the
 type traits classes - mostly this is a test of your compiler's
 support for the concepts used in the type traits implementation,
 while <a href="algo_opt_examples.cpp">algo_opt_examples.cpp</a>
 uses the type traits classes to &quot;optimise&quot; some
 familiar standard library algorithms.</p>
 <p>There are four algorithm examples in algo_opt_examples.cpp:</p>
 <table border="0" cellpadding="7" cellspacing="0" width="638">
    <tr>
        <td valign="top" width="50%"><pre>opt::copy</pre>
        </td>
        <td valign="top" width="50%">If the copy operation can be
        performed using memcpy then does so, otherwise uses a
        regular element by element copy (<i>c.f.</i> std::copy).</td>
    </tr>
    <tr>
        <td valign="top" width="50%"><pre>opt::fill</pre>
        </td>
        <td valign="top" width="50%">If the fill operation can be
        performed by memset, then does so, otherwise uses a
        regular element by element assign. Also uses call_traits
        to optimise how the parameters can be passed (<i>c.f.</i>
        std::fill).</td>
    </tr>
    <tr>
        <td valign="top" width="50%"><pre>opt::destroy_array</pre>
        </td>
        <td valign="top" width="50%">If the type in the array has
        a trivial destructor then does nothing, otherwise calls
        destructors for all elements in the array - this
        algorithm is the reverse of std::uninitialized_copy / std::uninitialized_fill.</td>
    </tr>
    <tr>
        <td valign="top" width="50%"><pre>opt::iter_swap</pre>
        </td>
        <td valign="top" width="50%">Determines whether the
        iterator is a proxy-iterator: if it is then does a &quot;slow
        and safe&quot; swap, otherwise calls std::swap on the
        assumption that std::swap may be specialised for the
        iterated type.</td>
    </tr>
 </table>
 <p>&nbsp;</p>
 <hr>
 <p>Revised 08<sup>th</sup> 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>
 </body>
 </html>
--- a/type_traits_test.cpp
+++ b/type_traits_test.cpp
@ -4,11 +4,7 @@
 //  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.
 // standalone test program for <boost/type_traits.hpp>
 /* Release notes:
   31st July 2000:
      Added extra tests for is_empty, is_convertible, alignment_of.
   23rd July 2000:
      Removed all call_traits tests to call_traits_test.cpp
      Removed all compressed_pair tests to compressed_pair_tests.cpp
@ -20,10 +16,36 @@
 #include <typeinfo>
 #include <boost/type_traits.hpp>
 #include "type_traits_test.hpp"
 using namespace boost;
 #ifdef __BORLANDC__
 #pragma option -w-ccc -w-rch -w-eff -w-aus
 #endif
 //
 // define tests here
 unsigned failures = 0;
 unsigned test_count = 0;
 #define value_test(v, x) ++test_count;\
                         if(v != x){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #define type_test(v, x)  ++test_count;\
                         if(is_same<v, x>::value == false){\
                           ++failures; \
                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
                           std::cout << "   expected type was " << #v << std::endl; \
                           std::cout << "   " << typeid(is_same<v, x>).name() << "::value is false" << std::endl; }
 #else
 #define type_test(v, x)  ++test_count;\
                         if(typeid(v) != typeid(x)){\
                           ++failures; \
                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
                           std::cout << "   expected type was " << #v << std::endl; \
                           std::cout << "   " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
 #endif
 // Since there is no compiler support, we should specialize:
 //  is_enum for all enumerations (is_enum implies is_POD)
 //  is_union for all unions
@ -137,33 +159,6 @@ template <> struct is_POD<empty_POD_union_UDT>
 }
 #endif
 class Base { };
 class Deriverd : public Base { };
 class NonDerived { };
 enum enum1
 {
   one_,two_
 };
 enum enum2
 {
   three_,four_
 };
 struct VB
 {
   virtual ~VB(){};
 };
 struct VD : VB
 {
   ~VD(){};
 };
 // Steve: All comments that I (Steve Cleary) have added below are prefixed with
 //  "Steve:"  The failures that BCB4 has on the tests are due to Borland's
 //  not considering cv-qual's as a part of the type -- they are considered
@ -443,12 +438,7 @@ int main()
   value_test(false, is_empty<int>::value)
   value_test(false, is_empty<int*>::value)
   value_test(false, is_empty<int&>::value)
 #ifdef __MWERKS__
   // apparent compiler bug causes this to fail to compile:
   value_fail(false, is_empty<int[2]>::value)
 #else
   value_test(false, is_empty<int[2]>::value)
 #endif
   value_test(false, is_empty<f1>::value)
   value_test(false, is_empty<mf1>::value)
   value_test(false, is_empty<UDT>::value)
@ -534,57 +524,6 @@ int main()
   value_test(false, is_POD<empty_UDT>::value)
   value_test(true, is_POD<enum_UDT>::value)
   value_test(true, (boost::is_convertible<Deriverd,Base>::value));
   value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
   value_test(true, (boost::is_convertible<Base,Base>::value));
   value_test(false, (boost::is_convertible<Base,Deriverd>::value));
   value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
   value_test(false, (boost::is_convertible<NonDerived,Base>::value));
   //value_test(false, (boost::is_convertible<boost::noncopyable, boost::noncopyable>::value));
   value_test(true, (boost::is_convertible<float,int>::value));
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   value_test(false, (boost::is_convertible<float,void>::value));
   value_test(false, (boost::is_convertible<void,float>::value));
   value_test(true, (boost::is_convertible<void,void>::value));
 #endif
   value_test(true, (boost::is_convertible<enum1, int>::value));
   value_test(true, (boost::is_convertible<Deriverd*, Base*>::value));
   value_test(false, (boost::is_convertible<Base*, Deriverd*>::value));
   value_test(true, (boost::is_convertible<Deriverd&, Base&>::value));
   value_test(false, (boost::is_convertible<Base&, Deriverd&>::value));
   value_test(true, (boost::is_convertible<const Deriverd*, const Base*>::value));
   value_test(false, (boost::is_convertible<const Base*, const Deriverd*>::value));
   value_test(true, (boost::is_convertible<const Deriverd&, const Base&>::value));
   value_test(false, (boost::is_convertible<const Base&, const Deriverd&>::value));
   value_test(false, (boost::is_convertible<const int *, int*>::value));
   value_test(false, (boost::is_convertible<const int&, int&>::value));
   value_test(false, (boost::is_convertible<int*, int[2]>::value));
   value_test(false, (boost::is_convertible<const int*, int[3]>::value));
   value_test(true, (boost::is_convertible<const int&, int>::value));
   value_test(true, (boost::is_convertible<int(&)[4], const int*>::value));
   value_test(true, (boost::is_convertible<int(&)(int), int(*)(int)>::value));
   value_test(true, (boost::is_convertible<int *, const int*>::value));
   value_test(true, (boost::is_convertible<int&, const int&>::value));
   value_test(true, (boost::is_convertible<int[2], int*>::value));
   value_test(true, (boost::is_convertible<int[2], const int*>::value));
   value_test(false, (boost::is_convertible<const int[2], int*>::value));
   align_test(int);
   align_test(char);
   align_test(double);
   align_test(int[4]);
   align_test(int(*)(int));
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   align_test(char&);
   align_test(char (&)(int));
   align_test(char(&)[4]);
 #endif
   align_test(int*);
   //align_test(const int);
   align_test(VB);
   align_test(VD);
   std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
   std::cin.get();
   return failures;
--- a/type_traits_test.hpp
+++ b/type_traits_test.hpp
@ -1,106 +0,0 @@
 // boost::compressed_pair test program   
 //  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
 //  distribute this software is granted provided this copyright notice appears   
 //  in all copies. This software is provided "as is" without express or implied   
 //  warranty, and with no claim as to its suitability for any purpose.   
 // common test code for type_traits_test.cpp/call_traits_test.cpp/compressed_pair_test.cpp
 #ifndef BOOST_TYPE_TRAITS_TEST_HPP
 #define BOOST_TYPE_TRAITS_TEST_HPP
 //
 // this one is here just to suppress warnings:
 //
 template <class T>
 bool do_compare(T i, T j)
 {
   return i == j;
 }
 //
 // this one is to verify that a constant is indeed a
 // constant-integral-expression:
 //
 template <int>
 struct ct_checker
 {
 };
 #define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
 #define BOOST_DO_JOIN2(X, Y) X ## Y
 #define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
 #define value_test(v, x) ++test_count;\
                         typedef ct_checker<(x)> BOOST_JOIN(this_is_a_compile_time_check_, __LINE__);\
                         if(!do_compare((int)v,(int)x)){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
 #define value_fail(v, x) ++test_count; ++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #define type_test(v, x)  ++test_count;\
                           if(do_compare(boost::is_same<v, x>::value, false)){\
                           ++failures; \
                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
                           std::cout << "   expected type was " << #v << std::endl; \
                           std::cout << "   " << typeid(boost::is_same<v, x>).name() << "::value is false" << std::endl; }
 #else
 #define type_test(v, x)  ++test_count;\
                         if(typeid(v) != typeid(x)){\
                           ++failures; \
                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
                           std::cout << "   expected type was " << #v << std::endl; \
                           std::cout << "   " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
 #endif
 template <class T>
 struct test_align
 {
   struct padded
   {
      char c;
      T t;
   };
   static void do_it()
   {
      padded p;
      unsigned a = reinterpret_cast<char*>(&(p.t)) - reinterpret_cast<char*>(&p);
      value_test(a, boost::alignment_of<T>::value);
   }
 };
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct test_align<T&>
 {
   static void do_it()
   {
      //
      // we can't do the usual test because we can't take the address
      // of a reference, so check that the result is the same as for a
      // pointer type instead:
      value_test(boost::alignment_of<T*>::value, boost::alignment_of<T&>::value);
   }
 };
 #endif
 #define align_test(T) test_align<T>::do_it()
 //
 // define tests here
 unsigned failures = 0;
 unsigned test_count = 0;
 //
 // turn off some warnings:
 #ifdef __BORLANDC__
 #pragma option -w-8004
 #endif
 #ifdef BOOST_MSVC
 #pragma warning (disable: 4018)
 #endif
 #endif // BOOST_TYPE_TRAITS_TEST_HPP
--- a/utility.htm
+++ b/utility.htm
@ -1,103 +0,0 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <title>Header boost/utility.hpp Documentation</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" WIDTH="277" HEIGHT="86">Header
 <a href="../../boost/utility.hpp">boost/utility.hpp</a></h1>
 <p>The entire contents of the header <code><a href="../../boost/utility.hpp">&lt;boost/utility.hpp&gt;</a></code>
 are in <code>namespace boost</code>.</p>
 <h2>Contents</h2>
 <ul>
  <li>Template functions <a href="#functions next">next() and prior()</a></li>
  <li>Class <a href="#Class noncopyable">noncopyable</a></li>
 </ul>
 <h2>Template <a name="functions next">functions next</a>() and prior()</h2>
 <p>Certain data types, such as the C++ Standard Library's forward and
 bidirectional iterators, do not provide addition and subtraction via operator+()
 or operator-().&nbsp; This means that non-modifying computation of the next or
 prior value requires a temporary, even though operator++() or operator--() is
 provided.&nbsp; It also means that writing code like <code>itr+1</code> inside a
 template restricts the iterator category to random access iterators.</p>
 <p>The next() and prior() functions provide a simple way around these problems:</p>
 <blockquote>
 <pre>template &lt;class T&gt;
 T next(T x) { return ++x; }
 template &lt;class X&gt;
 T prior(T x) { return --x; }</pre>
 </blockquote>
 <p>Usage is simple:</p>
 <blockquote>
 <pre>const std::list&lt;T&gt;::iterator p = get_some_iterator();
 const std::list&lt;T&gt;::iterator prev = boost::prior(p);</pre>
 </blockquote>
 <p>Contributed by <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>.</p>
 <h2><a name="Class noncopyable">Class noncopyable</a></h2>
 <p>Class <strong>noncopyable</strong> is a base class.&nbsp; Derive your own class from <strong>noncopyable</strong>
 when you want to prohibit copy construction and copy assignment.</p>
 <p>Some objects, particularly those which hold complex resources like files or
 network connections, have no sensible copy semantics.&nbsp; Sometimes there are
 possible copy semantics, but these would be of very limited usefulness and be
 very difficult to implement correctly.&nbsp; Sometimes you're implementing a class that doesn't need to be copied
 just yet and you don't want to take the time to write the appropriate functions.&nbsp;
 Deriving from <b> noncopyable</b> will prevent the otherwise implicitly-generated
 functions (which don't have the proper semantics) from becoming a trap for other programmers.</p>
 <p>The traditional way to deal with these is to declare a private copy constructor and copy assignment, and then
 document why this is done.&nbsp; But deriving from <b>noncopyable</b> is simpler
 and clearer, and doesn't require additional documentation.</p>
 <p>The program <a href="noncopyable_test.cpp">noncopyable_test.cpp</a> can be
 used to verify class <b>noncopyable</b> works as expected. It has have been run successfully under
 GCC 2.95, Metrowerks
 CodeWarrior 5.0, and Microsoft Visual C++ 6.0 sp 3.</p>
 <p>Contributed by <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>.</p>
 <h3>Example</h3>
 <blockquote>
  <pre>// inside one of your own headers ...
 #include &lt;boost/utility.hpp&gt;
 class ResourceLadenFileSystem : noncopyable {
 ...</pre>
 </blockquote>
 <h3>Rationale</h3>
 <p>Class noncopyable has protected constructor and destructor members to
 emphasize that it is to be used only as a base class.&nbsp; Dave Abrahams notes
 concern about the effect on compiler optimization of adding (even trivial inline)
 destructor declarations. He says &quot;Probably this concern is misplaced, because
 noncopyable will be used mostly for classes which own resources and thus have non-trivial destruction semantics.&quot;</p>
 <hr>
 <p>Revised&nbsp; <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
 -->26 January, 2000<!--webbot bot="Timestamp" endspan i-checksum="38194"
 -->
 </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>
Author	SHA1	Message	Date
Jeremy Siek	50817f6339	Added traits arguments to the iterator adaptor classes for vc++ port. [SVN r7671]	2000-08-01 00:45:42 +00:00
Dave Abrahams	2bd78704cc	A first stab at vc6 compatibility [SVN r7668]	2000-07-31 15:39:33 +00:00
Jeremy Siek	cf7f110c89	added include for algorithms [SVN r7654]	2000-07-27 18:35:03 +00:00
Jeremy Siek	e8deb965a1	new files for iterator_adaptors, includes testing, examples, and documentation [SVN r7651]	2000-07-27 17:59:40 +00:00
nobody	8454835ac4	This commit was manufactured by cvs2svn to create branch 'iterator-adaptors'. [SVN r7633]	2000-07-26 20:32:15 +00:00
Beman Dawes	13f6d43e5e	1.16.1 initial CVS checkin [SVN r7620]	2000-07-07 16:04:40 +00:00