This commit was manufactured by cvs2svn to create tag

'Version_1_20_1'. [SVN r8548]
compressed pair fixes for VC6
2025-10-07 14:30:55 +02:00 · 2001-01-10 18:29:12 +00:00 · 2001-01-10 12:21:30 +00:00 · 2001-01-06 16:47:36 +00:00 · 2000-12-21 12:27:22 +00:00 · 2000-12-09 22:39:50 +00:00
27 changed files with 5522 additions and 252 deletions
--- a/Assignable.html
+++ b/Assignable.html
@@ -0,0 +1,116 @@
 <HTML>
 <!--
  -- Copyright (c) Jeremy Siek 2000
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  Silicon Graphics makes no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  -->
 <Head>
 <Title>Assignable</Title>
 </HEAD>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
 <IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86"> 
 <!--end header-->
 <BR Clear>
 <H1>Assignable</H1>
 <h3>Description</h3>
 A type is Assignable if it is possible to assign one object of the type
 to another object 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 Assignable
 </TD>
 </TR>
 <TR>
 <TD VAlign=top>
 <tt>t</tt>
 </TD>
 <TD VAlign=top>
 is an object of type <tt>T</tt>
 </TD>
 </tr>
 <TR>
 <TD VAlign=top>
 <tt>u</tt>
 </TD>
 <TD VAlign=top>
 is an object of type <tt>T</tt> or possibly <tt>const T</tt>
 </TD>
 </tr>
 </table>
 <h3>Definitions</h3>
 <h3>Valid expressions</h3>
 <Table border>
 <TR>
 <TH>
 Name
 </TH>
 <TH>
 Expression
 </TH>
 <TH>
 Return type
 </TH>
 <TH>
 Semantics
 </TH>
 </TR>
 <TR>
 <TD VAlign=top>
 Assignment
 </TD>
 <TD VAlign=top>
 <tt>t = u</tt>
 </TD>
 <TD VAlign=top>
 <tt>T&amp;</tt>
 </TD>
 <TD VAlign=top>
 <tt>t</tt> is equivalent to <tt>u</tt>
 </TD>
 </TR>
 </table>
 </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="./CopyConstructible.html">CopyConstructible</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/CopyConstructible.html
+++ b/CopyConstructible.html
@@ -0,0 +1,210 @@
 <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" width="277" height="86"> 
 <!--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>Concept Checking Class</h3>
 <pre>
  template &lt;class T&gt;
  struct CopyConstructibleConcept
  {
    void constraints() {
      T a(b);            // require copy constructor
      T* ptr = &amp;a;       // require address of operator
      const_constraints(a);
      ignore_unused_variable_warning(ptr);
    }
    void const_constraints(const T&amp; a) {
      T c(a);            // require const copy constructor
      const T* ptr = &amp;a; // require const address of operator
      ignore_unused_variable_warning(c);
      ignore_unused_variable_warning(ptr);
    }
    T b;
  };
 </pre>
 <h3>See also</h3>
 <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/LessThanComparable.html
+++ b/LessThanComparable.html
@@ -0,0 +1,212 @@
 <HTML>
 <!--
  -- Copyright (c) Jeremy Siek 2000
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  Silicon Graphics makes no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  -->
 <!--
  -- Copyright (c) 1996-1999
  -- Silicon Graphics Computer Systems, Inc.
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  Silicon Graphics makes no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  --
  -- Copyright (c) 1994
  -- Hewlett-Packard Company
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  Hewlett-Packard Company makes no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  --
  -->
 <Head>
 <Title>LessThanComparable</Title>
 </Head>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
 <IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86"> 
 <!--end header-->
 <BR Clear>
 <H1>LessThanComparable</H1>
 <h3>Description</h3>
 A type is LessThanComparable if it is ordered: it must
 be possible to compare two objects of that type using <tt>operator&lt;</tt>, and
 <tt>operator&lt;</tt> must be a strict weak ordering relation.
 <h3>Refinement of</h3>
 <h3>Associated types</h3>
 <h3>Notation</h3>
 <Table>
 <TR>
 <TD VAlign=top>
 <tt>X</tt>
 </TD>
 <TD VAlign=top>
 A type that is a model of LessThanComparable
 </TD>
 </TR>
 <TR>
 <TD VAlign=top>
 <tt>x</tt>, <tt>y</tt>, <tt>z</tt>
 </TD>
 <TD VAlign=top>
 Object of type <tt>X</tt>
 </TD>
 </tr>
 </table>
 <h3>Definitions</h3>
 Consider the relation <tt>!(x &lt; y) &amp;&amp; !(y &lt; x)</tt>.  If this relation is
 transitive (that is, if <tt>!(x &lt; y) &amp;&amp; !(y &lt; x) &amp;&amp; !(y &lt; z) &amp;&amp; !(z &lt; y)</tt>
 implies <tt>!(x &lt; z) &amp;&amp; !(z &lt; x)</tt>), then it satisfies the mathematical
 definition of an equivalence relation.  In this case, <tt>operator&lt;</tt>
 is a <i>strict weak ordering</i>.
 <P>
 If <tt>operator&lt;</tt> is a strict weak ordering, and if each equivalence class
 has only a single element, then <tt>operator&lt;</tt> is a <i>total ordering</i>.
 <h3>Valid expressions</h3>
 <Table border>
 <TR>
 <TH>
 Name
 </TH>
 <TH>
 Expression
 </TH>
 <TH>
 Type requirements
 </TH>
 <TH>
 Return type
 </TH>
 </TR>
 <TR>
 <TD VAlign=top>
 Less
 </TD>
 <TD VAlign=top>
 <tt>x &lt; y</tt>
 </TD>
 <TD VAlign=top>
 &nbsp;
 </TD>
 <TD VAlign=top>
 Convertible to <tt>bool</tt>
 </TD>
 </TR>
 </table>
 <h3>Expression semantics</h3>
 <Table border>
 <TR>
 <TH>
 Name
 </TH>
 <TH>
 Expression
 </TH>
 <TH>
 Precondition
 </TH>
 <TH>
 Semantics
 </TH>
 <TH>
 Postcondition
 </TH>
 </TR>
 <TR>
 <TD VAlign=top>
 Less
 </TD>
 <TD VAlign=top>
 <tt>x &lt; y</tt>
 </TD>
 <TD VAlign=top>
 <tt>x</tt> and <tt>y</tt> are in the domain of <tt>&lt;</tt>
 </TD>
 <TD VAlign=top>
 &nbsp;
 </TD>
 </table>
 <h3>Complexity guarantees</h3>
 <h3>Invariants</h3>
 <Table border>
 <TR>
 <TD VAlign=top>
 Irreflexivity
 </TD>
 <TD VAlign=top>
 <tt>x &lt; x</tt> must be false.
 </TD>
 </TR>
 <TR>
 <TD VAlign=top>
 Antisymmetry
 </TD>
 <TD VAlign=top>
 <tt>x &lt; y</tt> implies !(y &lt; x) <A href="#2">[2]</A>
 </TD>
 </TR>
 <TR>
 <TD VAlign=top>
 Transitivity
 </TD>
 <TD VAlign=top>
 <tt>x &lt; y</tt> and <tt>y &lt; z</tt> implies <tt>x &lt; z</tt> <A href="#3">[3]</A>
 </TD>
 </tr>
 </table>
 <h3>Models</h3>
 <UL>
 <LI>
 int
 </UL>
 <h3>Notes</h3>
 <P><A name="1">[1]</A>
 Only <tt>operator&lt;</tt> is fundamental; the other inequality operators
 are essentially syntactic sugar.
 <P><A name="2">[2]</A>
 Antisymmetry is a theorem, not an axiom: it follows from
 irreflexivity and transitivity.
 <P><A name="3">[3]</A>
 Because of irreflexivity and transitivity, <tt>operator&lt;</tt> always
 satisfies the definition of a <i>partial ordering</i>.  The definition of
 a <i>strict weak ordering</i> is stricter, and the definition of a
 <i>total ordering</i> is stricter still.
 <h3>See also</h3>
 <A href="http://www.sgi.com/Technology/STL/EqualityComparable.html">EqualityComparable</A>, <A href="http://www.sgi.com/Technology/STL/StrictWeakOrdering.html">StrictWeakOrdering</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
@@ -0,0 +1,92 @@
 <HTML>
 <!--
  -- Copyright (c) Jeremy Siek 2000
  --
  -- Permission to use, copy, modify, distribute and sell this software
  -- and its documentation for any purpose is hereby granted without fee,
  -- provided that the above copyright notice appears in all copies and
  -- that both that copyright notice and this permission notice appear
  -- in supporting documentation.  Silicon Graphics makes no
  -- representations about the suitability of this software for any
  -- purpose.  It is provided "as is" without express or implied warranty.
  -->
 <Head>
 <Title>MultiPassInputIterator</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
 	ALINK="#ff0000"> 
 <IMG SRC="../../c++boost.gif" 
     ALT="C++ Boost" width="277" height="86"> 
 <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_arry:
+// algorithm destroy_array:
 // The reverse of std::unitialized_copy, takes a block of
 // unitialized memory and calls destructors on all objects therein.
 //
@@ -196,7 +196,7 @@ struct filler<true>
   template <typename I, typename T>
   static void do_fill(I first, I last, T val)
   {
-      memset(first, val, last-first);
+      std::memset(first, val, last-first);
   }
 };
@@ -421,3 +421,4 @@ int main()
--- a/c++_type_traits.htm
+++ b/c++_type_traits.htm
@@ -0,0 +1,489 @@
 <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
@@ -0,0 +1,754 @@
 <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. </p>
 <p>Note that for compilers that do not support either partial
 specialization or member templates, no benefit will occur from
 using call_traits: the call_traits defined types will always be
 the same as the existing practice in this case. In addition if
 only member templates and not partial template specialisation is
 support by the compiler (for example Visual C++ 6) then call_traits
 can not be used with array types (although it can be used to
 solve the reference to reference problem).</p>
 <table border="0" cellpadding="7" cellspacing="1" width="797">
    <tr>
        <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. Note that the function arguments to make_pair
 are not expressed in terms of call_traits: doing so would prevent
 template argument deduction from functioning.</p>
 <h4><a name="ex4"></a>Example 4 (optimising fill):</h4>
 <p>The call_traits template will &quot;optimize&quot; the passing
 of a small built-in type as a function parameter, this mainly has
 an effect when the parameter is used within a loop body. In the
 following example (see <a href="algo_opt_examples.cpp">algo_opt_examples.cpp</a>),
 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>
 <p>Note that the function arguments to fill are not expressed in
 terms of call_traits: doing so would prevent template argument
 deduction from functioning. Instead fill acts as a &quot;thin
 wrapper&quot; that is there to perform template argument
 deduction, the compiler will optimise away the call to fill all
 together, replacing it with the call to filler&lt;&gt;::do_fill,
 which does use call_traits.</p>
 <h3>Rationale</h3>
 <p>The following notes are intended to briefly describe the
 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 01 September 2000</p>
 <p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
 sell and distribute this document is granted provided this
 copyright notice appears in all copies. This document is provided
 &quot;as is&quot; without express or implied warranty, and with
 no claim as to its suitability for any purpose.</p>
 <p>Based on contributions by Steve Cleary, Beman Dawes, Howard
 Hinnant and John Maddock.</p>
 <p>Maintained by <a href="mailto:John_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,3 +1,13 @@
 // 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>
 // 03 Oct 2000:
 //    Enabled extra tests for VC6.
 #include <cassert>
 #include <iostream>
@@ -6,12 +16,7 @@
 #include <typeinfo>
 #include <boost/call_traits.hpp>
-#ifdef __BORLANDC__
+#include "type_traits_test.hpp"
 // 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:
@@ -113,7 +118,7 @@ void checker<T>::operator()(param_type p)
   assert(t == c.get());
   assert(t == c.const_get());
-   cout << "typeof contained<" << typeid(T).name() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
+   //cout << "typeof contained<" << typeid(T).name() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::value() is:      " << typeid(&contained<T>::value).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::get() is:        " << typeid(&contained<T>::get).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::const_get() is:  " << typeid(&contained<T>::const_get).name() << endl;
@@ -178,30 +183,6 @@ 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;
@@ -211,17 +192,18 @@ int main()
   int i = 2;
   c2(i);
   int* pi = &i;
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
   checker<int*> c3;
   c3(pi);
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   checker<int&> c4;
   c4(i);
   checker<const int&> c5;
   c5(i);
-
+#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   int a[2] = {1,2};
   checker<int[2]> c6;
   c6(a);
 #endif
 #endif
   check_wrap(wrap(2), 2);
@@ -250,7 +232,7 @@ int main()
   type_test(int*&, boost::call_traits<int*>::reference)
   type_test(int*const&, boost::call_traits<int*>::const_reference)
   type_test(int*const, boost::call_traits<int*>::param_type)
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
   type_test(int&, boost::call_traits<int&>::value_type)
   type_test(int&, boost::call_traits<int&>::reference)
   type_test(const int&, boost::call_traits<int&>::const_reference)
@@ -261,7 +243,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 << "GNU C++ cannot instantiate call_traits<cr_type>, skipping four tests (4 errors)" << std::endl;
+   std::cout << "Your compiler cannot instantiate call_traits<int&const>, skipping four tests (4 errors)" << std::endl;
   failures += 4;
   test_count += 4;
 #endif
@@ -269,6 +251,7 @@ int main()
   type_test(const int&, boost::call_traits<const int&>::reference)
   type_test(const int&, boost::call_traits<const int&>::const_reference)
   type_test(const int&, boost::call_traits<const int&>::param_type)
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   type_test(const int*, boost::call_traits<int[3]>::value_type)
   type_test(int(&)[3], boost::call_traits<int[3]>::reference)
   type_test(const int(&)[3], boost::call_traits<int[3]>::const_reference)
@@ -277,6 +260,11 @@ int main()
   type_test(const int(&)[3], boost::call_traits<const int[3]>::reference)
   type_test(const int(&)[3], boost::call_traits<const int[3]>::const_reference)
   type_test(const int*const, boost::call_traits<const int[3]>::param_type)
 #else
   std::cout << "You're compiler does not support partial template instantiation, skipping 8 tests (8 errors)" << std::endl;
   failures += 8;
   test_count += 8;
 #endif
 #else
   std::cout << "You're compiler does not support partial template instantiation, skipping 20 tests (20 errors)" << std::endl;
   failures += 20;
@@ -295,74 +283,84 @@ int main()
 template <typename T, bool isarray = false>
 struct call_traits_test
 {
-   static void assert_construct(boost::call_traits<T>::param_type val);
+   typedef ::boost::call_traits<T> ct;
   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(boost::call_traits<T>::param_type val)
+void call_traits_test<T, isarray>::assert_construct(typename call_traits_test<T, isarray>::param_type val)
 {
   //
   // this is to check that the call_traits assertions are valid:
   T t(val);
-   boost::call_traits<T>::value_type v(t);
+   value_type v(t);
-   boost::call_traits<T>::reference r(t);
+   reference r(t);
-   boost::call_traits<T>::const_reference cr(t);
+   const_reference cr(t);
-   boost::call_traits<T>::param_type p(t);
+   param_type p(t);
-   boost::call_traits<T>::value_type v2(v);
+   value_type v2(v);
-   boost::call_traits<T>::value_type v3(r);
+   value_type v3(r);
-   boost::call_traits<T>::value_type v4(p);
+   value_type v4(p);
-   boost::call_traits<T>::reference r2(v);
+   reference r2(v);
-   boost::call_traits<T>::reference r3(r);
+   reference r3(r);
-   boost::call_traits<T>::const_reference cr2(v);
+   const_reference cr2(v);
-   boost::call_traits<T>::const_reference cr3(r);
+   const_reference cr3(r);
-   boost::call_traits<T>::const_reference cr4(cr);
+   const_reference cr4(cr);
-   boost::call_traits<T>::const_reference cr5(p);
+   const_reference cr5(p);
-   boost::call_traits<T>::param_type p2(v);
+   param_type p2(v);
-   boost::call_traits<T>::param_type p3(r);
+   param_type p3(r);
-   boost::call_traits<T>::param_type p4(p);
+   param_type p4(p);
 }
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <typename T>
 struct call_traits_test<T, true>
 {
-   static void assert_construct(boost::call_traits<T>::param_type val);
+   typedef ::boost::call_traits<T> ct;
   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>
-void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_type val)
+void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>::param_type val)
 {
   //
   // this is to check that the call_traits assertions are valid:
   T t;
-   boost::call_traits<T>::value_type v(t);
+   value_type v(t);
-   boost::call_traits<T>::value_type v5(val);
+   value_type v5(val);
-   boost::call_traits<T>::reference r = t;
+   reference r = t;
-   boost::call_traits<T>::const_reference cr = t;
+   const_reference cr = t;
-   boost::call_traits<T>::reference r2 = r;
+   reference r2 = r;
   #ifndef __BORLANDC__
   // C++ Builder buglet:
-   boost::call_traits<T>::const_reference cr2 = r;
+   const_reference cr2 = r;
   #endif
-   boost::call_traits<T>::param_type p(t);
+   param_type p(t);
-   boost::call_traits<T>::value_type v2(v);
+   value_type v2(v);
-   boost::call_traits<T>::const_reference cr3 = cr;
+   const_reference cr3 = cr;
-   boost::call_traits<T>::value_type v3(r);
+   value_type v3(r);
-   boost::call_traits<T>::value_type v4(p);
+   value_type v4(p);
-   boost::call_traits<T>::param_type p2(v);
+   param_type p2(v);
-   boost::call_traits<T>::param_type p3(r);
+   param_type p3(r);
-   boost::call_traits<T>::param_type p4(p);
+   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>;
 template struct call_traits_test<const int>;
 template struct call_traits_test<int*>;
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
 template struct call_traits_test<int&>;
 template struct call_traits_test<const int&>;
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template struct call_traits_test<int[2], true>;
 #endif
-
+#endif
--- a/cast_test.cpp
+++ b/cast_test.cpp
@@ -1,149 +0,0 @@
 //  boost utility cast test program  -----------------------------------------//
 //  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
 //  and distribute this software is granted provided this copyright
 //  notice appears in all copies. This software is provided "as is" without
 //  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
 //  See http://www.boost.org for most recent version including documentation.
 //  Revision History
 //   28 Jun 00  implicit_cast removed (Beman Dawes)
 //   30 Aug 99  value_cast replaced by numeric_cast
 //    3 Aug 99  Initial Version
 #include <iostream>
 #include <climits>
 #include <limits>
 #include <boost/cast.hpp>
 #  if SCHAR_MAX == LONG_MAX
 #      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
 #  endif 
 using namespace boost;
 using std::cout;
 namespace
 {
    struct Base
    { 
        virtual char kind() { return 'B'; }
    };
    struct Base2
    { 
        virtual char kind2() { return '2'; }
    };
    struct Derived : public Base, Base2
    {
        virtual char kind() { return 'D'; }
    }; 
 }   
 int main( int argc, char * argv[] )
 {
    cout << "Usage: test_casts [n], where n omitted or is:\n"
            "  1 = execute #1 assert failure (#ifndef NDEBUG)\n"
            "  2 = execute #2 assert failure (#ifndef NDEBUG)\n"
            "Example: test_casts 2\n\n";
 #   ifdef NDEBUG
        cout << "NDEBUG is defined\n";
 #   else
        cout << "NDEBUG is not defined\n";
 #   endif
    cout << "\nBeginning tests...\n";        
 //  test polymorphic_cast  ---------------------------------------------------//
    //  tests which should succeed
    Base *    base = new Derived;
    Base2 *   base2 = 0;
    Derived * derived = 0;
    derived = polymorphic_downcast<Derived*>( base );  // downcast
    assert( derived->kind() == 'D' );
    derived = 0;
    derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
    assert( derived->kind() == 'D' );
    base2 = polymorphic_cast<Base2*>( base ); // crosscast
    assert( base2->kind2() == '2' );
     //  tests which should result in errors being detected
    int err_count = 0;
    base = new Base;
    if ( argc > 1 && *argv[1] == '1' )
        { derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
    bool caught_exception = false;
    try { derived = polymorphic_cast<Derived*>( base ); }
    catch (std::bad_cast)
        { cout<<"caught bad_cast\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    //  the following is just so generated code can be inspected
    if ( derived->kind() == 'B' ) ++err_count;
 //  test implicit_cast and numeric_cast  -------------------------------------//
    //  tests which should succeed
    long small_value = 1;
    long small_negative_value = -1;
    long large_value = std::numeric_limits<long>::max();
    long large_negative_value = std::numeric_limits<long>::min();
    signed char c = 0;
    c = large_value;  // see if compiler generates warning
    c = numeric_cast<signed char>( small_value );
    assert( c == 1 );
    c = 0;
    c = numeric_cast<signed char>( small_value );
    assert( c == 1 );
    c = 0;
    c = numeric_cast<signed char>( small_negative_value );
    assert( c == -1 );
    //  tests which should result in errors being detected
    caught_exception = false;
    try { c = numeric_cast<signed char>( large_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    caught_exception = false;
    try { c = numeric_cast<signed char>( large_negative_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    unsigned long ul;
    caught_exception = false;
    try { ul = numeric_cast<unsigned long>( large_negative_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    caught_exception = false;
    try { ul = numeric_cast<unsigned long>( small_negative_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    caught_exception = false;
    try { numeric_cast<int>( std::numeric_limits<double>::max() ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
    if ( !caught_exception ) ++err_count;
    cout << err_count << " errors detected\nTest "
         << (err_count==0 ? "passed\n" : "failed\n");
    return err_count;
 }   // main
--- a/compressed_pair.htm
+++ b/compressed_pair.htm
@@ -0,0 +1,92 @@
 <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
@@ -0,0 +1,159 @@
 // 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/compressed_pair.hpp>
 // Revised 03 Oct 2000: 
 //    Enabled tests for VC6.
 #include <iostream>
 #include <typeinfo>
 #include <cassert>
 #include <boost/compressed_pair.hpp>
 #include "type_traits_test.hpp"
 using namespace boost;
 struct empty_POD_UDT{};
 struct empty_UDT
 {
  ~empty_UDT(){};
 };
 namespace boost {
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 template <> struct is_empty<empty_UDT>
 { static const bool value = true; };
 template <> struct is_empty<empty_POD_UDT>
 { static const bool value = true; };
 template <> struct is_POD<empty_POD_UDT>
 { static const bool value = true; };
 #else
 template <> struct is_empty<empty_UDT>
 { enum{ value = true }; };
 template <> struct is_empty<empty_POD_UDT>
 { enum{ value = true }; };
 template <> struct is_POD<empty_POD_UDT>
 { enum{ value = true }; };
 #endif
 }
 struct non_empty1
 { 
   int i;
   non_empty1() : i(1){}
   non_empty1(int v) : i(v){}
   friend bool operator==(const non_empty1& a, const non_empty1& b)
   { return a.i == b.i; }
 };
 struct non_empty2
 { 
   int i;
   non_empty2() : i(3){}
   non_empty2(int v) : i(v){}
   friend bool operator==(const non_empty2& a, const non_empty2& b)
   { return a.i == b.i; }
 };
 int main()
 {
   compressed_pair<int, double> cp1(1, 1.3);
   assert(cp1.first() == 1);
   assert(cp1.second() == 1.3);
   compressed_pair<int, double> cp1b(2, 2.3);
   assert(cp1b.first() == 2);
   assert(cp1b.second() == 2.3);
   swap(cp1, cp1b);
   assert(cp1b.first() == 1);
   assert(cp1b.second() == 1.3);
   assert(cp1.first() == 2);
   assert(cp1.second() == 2.3);
   compressed_pair<non_empty1, non_empty2> cp1c(non_empty1(9));
   assert(cp1c.second() == non_empty2());
   assert(cp1c.first() == non_empty1(9));
   compressed_pair<non_empty1, non_empty2> cp1d(non_empty2(9));
   assert(cp1d.second() == non_empty2(9));
   assert(cp1d.first() == non_empty1());
   compressed_pair<int, double> cp1e(cp1);
   compressed_pair<empty_UDT, int> cp2(2);
   assert(cp2.second() == 2);
   compressed_pair<int, empty_UDT> cp3(1);
   assert(cp3.first() ==1);
   compressed_pair<empty_UDT, empty_UDT> cp4;
   compressed_pair<empty_UDT, empty_POD_UDT> cp5;
   compressed_pair<int, empty_UDT> cp9(empty_UDT());
   compressed_pair<int, empty_UDT> cp10(1);
   assert(cp10.first() == 1);
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   int i = 0;
   compressed_pair<int&, int&> cp6(i,i);
   assert(cp6.first() == i);
   assert(cp6.second() == i);
   assert(&cp6.first() == &i);
   assert(&cp6.second() == &i);
   compressed_pair<int, double[2]> cp7;
   cp7.first();
   double* pd = cp7.second();
 #endif
   value_test(true, (sizeof(compressed_pair<empty_UDT, int>) < sizeof(std::pair<empty_UDT, int>)))
   value_test(true, (sizeof(compressed_pair<int, empty_UDT>) < sizeof(std::pair<int, empty_UDT>)))
   value_test(true, (sizeof(compressed_pair<empty_UDT, empty_UDT>) < sizeof(std::pair<empty_UDT, empty_UDT>)))
   value_test(true, (sizeof(compressed_pair<empty_UDT, empty_POD_UDT>) < sizeof(std::pair<empty_UDT, empty_POD_UDT>)))
   value_test(true, (sizeof(compressed_pair<empty_UDT, compressed_pair<empty_POD_UDT, int> >) < sizeof(std::pair<empty_UDT, std::pair<empty_POD_UDT, int> >)))
   std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
   std::cin.get();
   return failures;
 }
 //
 // 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
 #ifndef __MWERKS__
 //
 // now some for which only a few specific members can be instantiated,
 // first references:
 template double& compressed_pair<double, int&>::first();
 template int& compressed_pair<double, int&>::second();
 #if !(defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ < 95))
 template compressed_pair<double, int&>::compressed_pair(int&);
 #endif
 template compressed_pair<double, int&>::compressed_pair(call_traits<double>::param_type,int&);
 //
 // and then arrays:
 #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();
 #if !(defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ < 95))
 template compressed_pair<double, int[2]>::compressed_pair(call_traits<double>::param_type);
 #endif
 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,6 +6,9 @@
 //  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)
@@ -73,7 +76,7 @@ struct call_traits<T&>
   typedef T& param_type;  // hh removed const
 };
-#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x550)
+#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
 // 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,6 +6,8 @@
 //  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
@@ -73,7 +75,9 @@ namespace details
   template <typename T>
   inline void cp_swap(T& t1, T& t2)
   {
 #ifndef __GNUC__
      using std::swap;
 #endif
      swap(t1, t2);
   }
--- a/include/boost/detail/ob_call_traits.hpp
+++ b/include/boost/detail/ob_call_traits.hpp
@@ -7,7 +7,16 @@
 //  See http://www.boost.org for most recent version including documentation.
 //
 //  Crippled version for crippled compilers:
 //  see libs/utility/call_traits.htm
 //
 /* Release notes:
   01st October 2000:
      Fixed call_traits on VC6, using "poor man's partial specialisation",
      using ideas taken from "Generative programming" by Krzysztof Czarnecki 
      & Ulrich Eisenecker.
 */
 #ifndef BOOST_OB_CALL_TRAITS_HPP
 #define BOOST_OB_CALL_TRAITS_HPP
@@ -21,6 +30,85 @@
 namespace boost{
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
 //
 // use member templates to emulate
 // partial specialisation:
 //
 namespace detail{
 template <class T>
 struct standard_call_traits
 {
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef const T& param_type;
 };
 template <class T>
 struct simple_call_traits
 {
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef const T param_type;
 };
 template <class T>
 struct reference_call_traits
 {
   typedef T value_type;
   typedef T reference;
   typedef T const_reference;
   typedef T param_type;
 };
 template <bool simple, bool reference>
 struct call_traits_chooser
 {
   template <class T>
   struct rebind
   {
      typedef standard_call_traits<T> type;
   };
 };
 template <>
 struct call_traits_chooser<true, false>
 {
   template <class T>
   struct rebind
   {
      typedef simple_call_traits<T> type;
   };
 };
 template <>
 struct call_traits_chooser<false, true>
 {
   template <class T>
   struct rebind
   {
      typedef reference_call_traits<T> type;
   };
 };
 } // namespace detail
 template <typename T>
 struct call_traits
 {
 private:
   typedef detail::call_traits_chooser<(is_pointer<T>::value || is_arithmetic<T>::value) && sizeof(T) <= sizeof(void*), is_reference<T>::value> chooser;
   typedef typename chooser::template rebind<T> bound_type;
   typedef typename bound_type::type call_traits_type;
 public:
   typedef typename call_traits_type::value_type       value_type;
   typedef typename call_traits_type::reference        reference;
   typedef typename call_traits_type::const_reference  const_reference;
   typedef typename call_traits_type::param_type       param_type;
 };
 #else
 //
 // sorry call_traits is completely non-functional
 // blame your broken compiler:
 //
 template <typename T>
 struct call_traits
 {
@@ -30,6 +118,8 @@ struct call_traits
   typedef const T& param_type;
 };
 #endif // member templates
 }
 #endif // BOOST_OB_CALL_TRAITS_HPP
--- a/include/boost/detail/ob_compressed_pair.hpp
+++ b/include/boost/detail/ob_compressed_pair.hpp
@@ -5,8 +5,13 @@
 //  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:
 	07 Oct 2000:
 		Added better single argument constructor support.
   03 Oct 2000:
      Added VC6 support (JM).
   23rd July 2000:
      Additional comments added. (JM)
   Jan 2000:
@@ -28,6 +33,392 @@
 namespace boost
 {
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
 //
 // use member templates to emulate
 // partial specialisation.  Note that due to
 // problems with overload resolution with VC6
 // each of the compressed_pair versions that follow
 // have one template single-argument constructor
 // in place of two specific constructors:
 //
 template <class T1, class T2>
 class compressed_pair;
 namespace detail{
 template <class A, class T1, class T2>
 struct best_convertion_traits
 {
   typedef char one;
   typedef char (&two)[2];
   static A a;
   static one test(T1);
   static two test(T2);
   enum { value = sizeof(test(a)) };
 };
 template <int>
 struct init_one;
 template <>
 struct init_one<1>
 {
   template <class A, class T1, class T2>
   static void init(const A& a, T1* p1, T2*)
   {
      *p1 = a;
   }
 };
 template <>
 struct init_one<2>
 {
   template <class A, class T1, class T2>
   static void init(const A& a, T1*, T2* p2)
   {
      *p2 = a;
   }
 };
 // T1 != T2, both non-empty
 template <class T1, class T2>
 class compressed_pair_0
 {
 private:
   T1 _first;
   T2 _second;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_0() : _first(), _second() {}
            compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
   template <class A>
   explicit compressed_pair_0(const A& val)
   {
      init_one<best_convertion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
   }
   compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
      : _first(x._first), _second(x._second) {}
   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }
   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }
   void swap(compressed_pair_0& y)
   {
      using std::swap;
      swap(_first, y._first);
      swap(_second, y._second);
   }
 };
 // T1 != T2, T2 empty
 template <class T1, class T2>
 class compressed_pair_1 : T2
 {
 private:
   T1 _first;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_1() : T2(), _first() {}
            compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}
   template <class A>
   explicit compressed_pair_1(const A& val)
   {
      init_one<best_convertion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
   }
   compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
      : T2(x), _first(x._first) {}
   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }
   second_reference       second()       { return *this; }
   second_const_reference second() const { return *this; }
   void swap(compressed_pair_1& y)
   {
      // no need to swap empty base class:
      using std::swap;
      swap(_first, y._first);
   }
 };
 // T1 != T2, T1 empty
 template <class T1, class T2>
 class compressed_pair_2 : T1
 {
 private:
   T2 _second;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_2() : T1(), _second() {}
            compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
   template <class A>
   explicit compressed_pair_2(const A& val)
   {
      init_one<best_convertion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
   }
   compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
      : T1(x), _second(x._second) {}
   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }
   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }
   void swap(compressed_pair_2& y)
   {
      // no need to swap empty base class:
      using std::swap;
      swap(_second, y._second);
   }
 };
 // T1 != T2, both empty
 template <class T1, class T2>
 class compressed_pair_3 : T1, T2
 {
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_3() : T1(), T2() {}
            compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
   template <class A>
   explicit compressed_pair_3(const A& val)
   {
      init_one<best_convertion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));
   }
   compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
      : T1(x), T2(x) {}
   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }
   second_reference       second()       { return *this; }
   second_const_reference second() const { return *this; }
   void swap(compressed_pair_3& y)
   {
      // no need to swap empty base classes:
   }
 };
 // T1 == T2, and empty
 template <class T1, class T2>
 class compressed_pair_4 : T1
 {
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_4() : T1() {}
            compressed_pair_4(first_param_type x, second_param_type) : T1(x) {}
   // only one single argument constructor since T1 == T2
   explicit compressed_pair_4(first_param_type x) : T1(x) {}
   compressed_pair_4(const ::boost::compressed_pair& x)
      : T1(x){}
   first_reference       first()       { return *this; }
   first_const_reference first() const { return *this; }
   second_reference       second()       { return *this; }
   second_const_reference second() const { return *this; }
   void swap(compressed_pair_4& y)
   {
      // no need to swap empty base classes:
   }
 };
 // T1 == T2, not empty
 template <class T1, class T2>
 class compressed_pair_5
 {
 private:
   T1 _first;
   T2 _second;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair_5() : _first(), _second() {}
            compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}
   // only one single argument constructor since T1 == T2
   explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}
   compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c) 
      : _first(c.first()), _second(c.second()) {}
   first_reference       first()       { return _first; }
   first_const_reference first() const { return _first; }
   second_reference       second()       { return _second; }
   second_const_reference second() const { return _second; }
   void swap(compressed_pair_5& y)
   {
      using std::swap;
      swap(_first, y._first);
      swap(_second, y._second);
   }
 };
 template <bool e1, bool e2, bool same>
 struct compressed_pair_chooser
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_0<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<false, true, false>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_1<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<true, false, false>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_2<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<true, true, false>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_3<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<true, true, true>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_4<T1, T2> type;
   };
 };
 template <>
 struct compressed_pair_chooser<false, false, true>
 {
   template <class T1, class T2>
   struct rebind
   {
      typedef compressed_pair_5<T1, T2> type;
   };
 };
 template <class T1, class T2>
 struct compressed_pair_traits
 {
 private:
   typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;
   typedef typename chooser::template rebind<T1, T2> bound_type;
 public:
   typedef typename bound_type::type type;
 };
 } // namespace detail
 template <class T1, class T2>
 class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type
 {
 private:
   typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;
 public:
   typedef T1                                                 first_type;
   typedef T2                                                 second_type;
   typedef typename call_traits<first_type>::param_type       first_param_type;
   typedef typename call_traits<second_type>::param_type      second_param_type;
   typedef typename call_traits<first_type>::reference        first_reference;
   typedef typename call_traits<second_type>::reference       second_reference;
   typedef typename call_traits<first_type>::const_reference  first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair() : base_type() {}
            compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}
   template <class A>
   explicit compressed_pair(const A& x) : base_type(x){}
   first_reference       first()       { return base_type::first(); }
   first_const_reference first() const { return base_type::first(); }
   second_reference       second()       { return base_type::second(); }
   second_const_reference second() const { return base_type::second(); }
 };
 template <class T1, class T2>
 inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
 {
   x.swap(y);
 }
 #else
 // no partial specialisation, no member templates:
 template <class T1, class T2>
 class compressed_pair
@@ -71,7 +462,11 @@ inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
   x.swap(y);
 }
 #endif
 } // boost
 #endif // BOOST_OB_COMPRESSED_PAIR_HPP
--- a/include/boost/operators.hpp
+++ b/include/boost/operators.hpp
@@ -69,6 +69,10 @@
 #pragma set woff 1234
 #endif
 #if defined(BOOST_MSVC)
 #   pragma warning( disable : 4284 ) // complaint about return type of 
 #endif                               // operator-> not begin a UDT
 namespace boost {
 namespace detail {
--- a/include/boost/utility.hpp
+++ b/include/boost/utility.hpp
@@ -24,6 +24,7 @@
 #include <boost/config.hpp>
 #include <cstddef>            // for size_t
 #include <utility>            // for std::pair
 namespace boost
 {
@@ -63,6 +64,32 @@ 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/iterator_adaptor_examples.cpp
+++ b/iterator_adaptor_examples.cpp
@@ -0,0 +1,47 @@
 // (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
 // distribute this software is granted provided this copyright notice appears
 // in all copies. This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 #include <functional>
 #include <algorithm>
 #include <iostream>
 #include <boost/pending/iterator_adaptors.hpp>
 #include <boost/pending/integer_range.hpp>
 int
 main(int, char*[])
 {
  // This is a simple example of using the transform_iterators class to
  // generate iterators that multiply the value returned by dereferencing
  // the iterator. In this case we are multiplying by 2.
  // Would be cooler to use lambda library in this example.
  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
  typedef std::binder1st< std::multiplies<int> > Function;
  typedef boost::transform_iterator<Function, int*, 
    boost::iterator<std::random_access_iterator_tag, int>
  >::type doubling_iterator;
  doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
    i_end(x + sizeof(x)/sizeof(int), std::bind1st(std::multiplies<int>(), 2));
  std::cout << "multiplying the array by 2:" << std::endl;
  while (i != i_end)
    std::cout << *i++ << " ";
  std::cout << std::endl;
  // Here is an example of counting from 0 to 5 using the integer_range class.
  boost::integer_range<int> r(0,5);
  std::cout << "counting to from 0 to 4:" << std::endl;
  std::copy(r.begin(), r.end(), std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;
  return 0;
 }
--- a/iterator_adaptor_test.cpp
+++ b/iterator_adaptor_test.cpp
@@ -0,0 +1,176 @@
 //  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 <boost/config.hpp>
 #include <iostream>
 #include <algorithm>
 #include <functional>
 #include <boost/pending/iterator_adaptors.hpp>
 #include <boost/pending/iterator_tests.hpp>
 #include <boost/pending/integer_range.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;
 };
 template <class Pair>
 struct select1st_ 
  : public std::unary_function<Pair, typename Pair::first_type>
 {
  const typename Pair::first_type& operator()(const Pair& x) const {
    return x.first;
  }
  typename Pair::first_type& operator()(Pair& x) const {
    return x.first;
  }
 };
 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_iterators
  {
    dummyT* ptr[N];
    for (int k = 0; k < N; ++k)
      ptr[k] = array + k;
    typedef boost::indirect_iterators<dummyT**, dummyT*, const dummyT*,
      boost::iterator<std::random_access_iterator_tag, dummyT*>,
      boost::iterator<std::random_access_iterator_tag, dummyT>,
      boost::iterator<std::random_access_iterator_tag, const 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 projection_iterators
  {    
    typedef std::pair<dummyT,dummyT> Pair;
    Pair pair_array[N];
    for (int k = 0; k < N; ++k)
      pair_array[k].first = array[k];
    typedef boost::projection_iterators<select1st_<Pair>,
      Pair*, const Pair*,
      boost::iterator<std::random_access_iterator_tag, Pair>,
      boost::iterator<std::random_access_iterator_tag, const Pair>
      > Projection;
    Projection::iterator i = pair_array;
    boost::random_access_iterator_test(i, N, array);
    Projection::const_iterator j = pair_array;
    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
@@ -0,0 +1,809 @@
 <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/iterator_adaptors.hpp Documentation</title>
 </head>
 <body bgcolor="#FFFFFF" text="#000000">
 <img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
 align="center" width="277" height="86">
 <h1>Header
 <a href="../../boost/pending/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
 and
 <a href="../../boost/pending/integer_range.hpp">boost/integer_range.hpp</a></h1>
 <p>The file <tt>boost/iterator_adaptors.hpp</tt>
 includes the main <tt>iterator_adaptors</tt> class and several other classes
 for constructing commonly used iterator adaptors.</p>
 <ul>
  <li><a href="#iterator_adaptors"><tt>iterator_adaptors</tt></a>.
  <li><a href="#iterator_adaptor"><tt>iterator_adaptor</tt></a>.
  <li><a href="#transform_iterator"><tt>transform_iterator</tt></a>
  <li><a href="#indirect_iterators"><tt>Indirect Iterator Adaptors</tt></a>
  <li><a href="#projection_iterators"><tt>Projection Iterator Adaptors</tt></a>
  <li><a href="#reverse_iterators"><tt>reverse_iterators</tt></a>
 </ul>
 <p>The file <tt>boost/integer_range.hpp</tt> includes a class that
  uses iterator adaptors to create an iterator that increments over a
  range of integers. The file also includes a &quot;container&quot; type
  that creates a container-interface for the range of integers.
 <ul>
  <li><a href="#integer_range"><tt>integer_range</tt></a>
 </ul>
 <!-- put in something about Andrei Alexandrescu's contribution? -->
 <p><a href="http://www.boost.org/people/dave_abrahams.htm">Dave
 Abrahams</a> started the library, coming up with the idea to use
 policy classes and how to handle the const/non-const iterator
 interactions. He also contributed the <tt>indirect_iterators</tt> and
 <tt>reverse_iterators</tt> classes.<br>
 <a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>
 contributed <tt>transform_iterator</tt>, <tt>integer_range</tt>,
 and this documentation.<br>
 <a href="http://www.boost.org/people/john_potter.htm">John Potter</a>
 contributed <tt>indirect_iterator</tt> and <tt>projection_iterator</tt>
 and made some simplifications to <tt>iterator_adaptor</tt>.
 <h3><a name="iterator_adaptors">The Iterator Adaptors Class</a></h3>
 Implementing standard conforming iterators is a non-trivial task.
 There are some fine-points such as iterator/const_iterator
 interactions and there are the myriad of operators that should be
 implemented but are easily forgotten such as
 <tt>operator-&gt;()</tt>. The purpose of the
 <tt>iterator_adaptors</tt> class is to make it easier to implement an
 iterator class, and even easier to extend and adapt existing iterator
 types. The <tt>iterator_adaptors</tt> class itself is not an adaptor
 class but a <i>type generator</i>. It generates a pair of adaptor classes,
 one class for the mutable iterator and one class for the const
 iterator. The definition of the <tt>iterator_adaptors</tt> class is as
 follows:
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class Iterator,
          class ConstIterator,
          class Traits = std::iterator_traits&lt;Iterator&gt;,
          class ConstTraits = std::iterator_traits&lt;ConstIterator&gt;,
          class Policies = default_iterator_policies&gt;
 struct iterator_adaptors
 {
  typedef ... iterator;
  typedef ... const_iterator;
 };
 </PRE></TD></TABLE>
 <p>The <tt>Iterator</tt> and <tt>ConstIterator</tt> template parameters
 are the iterator types that you want to adapt. The <tt>Traits</tt> and
 <tt>ConstTraits</tt> must be iterator traits classes.  The traits
 parameters default to the specialization of the
 <tt>std::iterator_traits</tt> class for the adapted iterators. If you
 want the traits for your new iterator adaptor (<tt>value_type</tt>,
 <tt>iterator_category</tt>, etc.) to be the same as the adapted
 iterator then use the default, otherwise create your own traits
 classes and pass them in <a href="#1">[1]</a>. 
 <p>The <tt>Policies</tt> class that you pass in will become the heart of
 the iterator adaptor. The policy class determines how your new adaptor
 class will behave. The <tt>Policies</tt> class must implement 3, 4, or
 7 of the core iterator operations depending on whether you wish the
 new iterator adaptor class to be a
 <a href="http://www.sgi.com/Technology/STL/ForwardIterator.html">
 ForwardIterator</a>,
 <a href="http://www.sgi.com/Technology/STL/BidirectionalIterator.html">
 BidirectionalIterator</a>, or <a
 href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html">
 RandomAccessIterator</a>. Make sure that the
 <tt>iterator_category</tt> type of the traits class you pass in
 matches the category of iterator that you want to create. The default
 policy class, <tt>default_iterator_policies</tt>, implements all 7 of
 the core operations in the usual way. If you wish to create an
 iterator adaptor that only changes a few of the iterator's behaviors,
 then you can have your new policy class inherit from
 <tt>default_iterator_policies</tt> to avoid retyping the usual
 behaviours. You should also look at <tt>default_iterator_policies</tt>
 as the &quot;boiler-plate&quot; for your own policy classes. The
 following is definition of the <tt>default_iterator_policies</tt>
 class:
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 struct default_iterator_policies
 {
  // required for a ForwardIterator
  template &lt;class Reference, class Iterator&gt;
  Reference dereference(type&lt;Reference&gt;, const Iterator& x) const
    { return *x; }
  template &lt;class Iterator&gt;
  static void increment(Iterator& x)
    { ++x; }
  template &lt;class Iterator1, class Iterator2&gt;
  bool equal(Iterator1& x, Iterator2& y) const
    { return x == y; }
  // required for a BidirectionalIterator
  template &lt;class Iterator&gt;
  static void decrement(Iterator& x)
    { --x; }
  // required for a RandomAccessIterator
  template &lt;class Iterator, class DifferenceType&gt;
  static void advance(Iterator& x, DifferenceType n)
    { x += n; }
  template &lt;class Difference, class Iterator1, class Iterator2&gt;
  Difference distance(type&lt;Difference&gt;, Iterator1& x, Iterator2& y) const
    { return y - x; }
  template &lt;class Iterator1, class Iterator2&gt;
  bool less(Iterator1& x, Iterator2& y) const
    { return x &lt; y; }
 };
 </PRE></TD></TABLE>
 <p>
 The generated iterator adaptor types will have the following
 constructors.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 <i>iterator</i>(const Iterator& i, const Policies& p = Policies())
 <i>const_iterator</i>(const ConstIterator& i, const Policies& p = Policies())
 </PRE></TD></TABLE>
 <h3><a name="iterator_adaptor">The Iterator Adaptor Class</a></h3>
 This is the class used inside of the <tt>iterator_adaptors</tt> type
 generator. Use this class directly (instead of using
 <tt>iterator_adaptors</tt>) when you are interested in creating only
 one of the iterator types (either const or non-const) or when there is
 no difference between the const and non-const versions of the iterator
 type (often this is because there is only a const (read-only) version
 of the iterator, as is the case for <tt>std::set</tt>'s iterators).
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class Iterator,
          class Policies = default_iterator_policies,
          class Traits = std::iterator_traits&lt;Iterator&gt; &gt;
 struct iterator_adaptor;
 </PRE></TD></TABLE>
 <p>
 Next we will look at some iterator adaptors that are examples of how
 to use the iterator adaptors class, and that are useful iterator
 adaptors in their own right.
 <h3><a name="transform_iterator">The Transform Iterator Class</a></h3>
 It is often useful to automatically apply some function to the value
 returned by dereferencing (<tt>operator*()</tt>) an iterator. The
 <tt>transform_iterators</tt> class makes it easy to create an iterator
 adaptor that does just that.
 First let us consider what the <tt>Policies</tt> class for the transform
 iterator should look like. We are only changing one of the iterator
 behaviours, so we will inherit from
 <tt>default_iterator_policies</tt>. In addition, we will need a
 function object to apply, so we will have a template parameter and a
 data member for the function object. The function will take one
 argument (the dereferenced value) and we will need to know the
 <tt>result_type</tt> of the function, so <a
 href="http://www.sgi.com/Technology/STL/AdaptableUnaryFunction.html">
 AdaptableUnaryFunction</a> is the corrent concept to choose for the
 function object type. Now for the heart of our iterator adaptor, we
 implement the <tt>dereference</tt> method, applying the function
 object to <tt>*i</tt>. The <tt>type&lt;Reference&gt;</tt> class is
 there to tell you what the reference type of the iterator is, which is
 handy when writing generic iterator adaptors such as this one <a
 href="#2">[2]</a>.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
  template &lt;class AdaptableUnaryFunction&gt;
  struct transform_iterator_policies : public default_iterator_policies
  {
    transform_iterator_policies() { }
    transform_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
    template &lt;class Reference, class Iterator&gt;
    Reference dereference(type&lt;Reference&gt;, const Iterator& i) const
      { return m_f(*i); }
    AdaptableUnaryFunction m_f;
  };
 </PRE></TD></TABLE>
 Next we need to create the traits class for our new iterator.  In some
 situations you may need to create a separate traits class for the
 const and non-const iterator types, but here a single traits class
 will do. The <tt>value_type</tt> and <tt>reference</tt> type of our
 transform iterator will be the <tt>result_type</tt> of the function
 object.  The <tt>difference_type</tt> and <tt>iterator_category</tt>
 will be the same as the adapted iterator.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
  template &lt;class AdaptableUnaryFunction, class IteratorTraits&gt;
  struct transform_iterator_traits {
    typedef typename AdaptableUnaryFunction::result_type value_type;
    typedef value_type reference;
    typedef value_type* pointer;
    typedef typename IteratorTraits::difference_type difference_type;
    typedef typename IteratorTraits::iterator_category iterator_category;
  };
 </PRE></TD></TABLE>
 The final step is to use the <tt>iterator_adaptor</tt> class to
 construct our transform iterator. We will use the single iterator
 adaptor version because we will not need to create both a mutable and
 const version of the transform iterator. The transform iterator is
 inherently a read-only iterator.  The nicest way to package up our new
 transform iterator is to create a type generator similar to
 <tt>iterator_adaptor</tt>. The first template parameter will be the
 type of the function object. The second parameter will be the adapted
 iterator type. The third parameter is the trait class for
 the adapted iterator.  Inside the <tt>transform_iterators</tt> class
 we use the <tt>transform_iterator_traits</tt> class defined above to
 create the traits class for the new transform iterator. We then use
 the <tt>iterator_adaptor</tt> class to extract the generated
 iterator adaptor type.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class AdaptableUnaryFunction,
          class Iterator,
          class Traits = std::iterator_traits&lt;Iterator&gt;
         &gt;
 struct transform_iterator
 {
  typedef transform_iterator_traits&lt;AdaptableUnaryFunction,Traits&gt;
    TransTraits;
  typedef iterator_adaptor&lt;Iterator, TransTraits,
    transform_iterator_policies&lt;AdaptableUnaryFunction&gt; &gt;::type type;
 };
 </PRE></TD></TABLE>
 <p>
 The following is a simple example of how to use the
 <tt>transform_iterators</tt> class to iterate through a range of
 numbers, multiplying each of them by 2 when they are dereferenced.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 #include &lt;functional&gt;
 #include &lt;iostream&gt;
 #include &lt;boost/iterator_adaptors.hpp&gt;
 int
 main(int, char*[])
 {
  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
  typedef std::binder1st&lt; std::multiplies&lt;int&gt; &gt; Function;
  typedef boost::transform_iterator&lt;Function, int*, 
    boost::iterator&lt;std::random_access_iterator_tag, int&gt;
  &gt;::type doubling_iterator;
  doubling_iterator i(x, std::bind1st(std::multiplies&lt;int&gt;(), 2)),
    i_end(x + sizeof(x)/sizeof(int), std::bind1st(std::multiplies&lt;int&gt;(), 2));
  std::cout &lt;&lt; "multiplying the array by 2:" &lt;&lt; std::endl;
  while (i != i_end)
    std::cout &lt;&lt; *i++ &lt;&lt; " ";
  std::cout &lt;&lt; std::endl;
  return 0;
 }
 </PRE></TD></TABLE>
 <h3><a name="indirect_iterators">The Indirect Iterator Adaptors</a></h3>
 It is not all that uncommon to create data structures that consist of
 pointers to pointers. For such a structure it might be nice to have an
 iterator that applies a double-dereference inside the
 <tt>operator*()</tt>. The implementation of this is similar to the
 <tt>transform_iterators</tt><a href="#3">[3]</a>. When talking about a
 data structure of pointers to pointers (or more generally, iterators
 to iterators), we call the first level iterators the <i>outer</i>
 iterators and the second level iterators the <i>inner</i>
 iterators. For example, if the outer iterator type is <tt>T**</tt>
 then the inner iterator type is <tt>T*</tt>.
 To implement the indirect adaptors, we first create a policies class
 which does a double-dereference in the <tt>dereference()</tt> method.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 struct indirect_iterator_policies : public default_iterator_policies
 {
    template &lt;class Reference, class Iterator&gt;
    Reference dereference(type&lt;Reference&gt;, const Iterator& x) const
        { return **x; }
 };
 </PRE></TD></TABLE>
 We then create a traits class, including a template parameter for both
 the inner and outer iterators and traits classes. The
 <tt>difference_type</tt> and <tt>iterator_category</tt> come from the
 outer iterator, while the <tt>value_type</tt>, <tt>pointer</tt>, and
 <tt>reference</tt> types come from the inner iterator.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class OuterIterator, class InnerIterator,
          class OuterTraits = std::iterator_traits&lt;OuterIterator&gt;,
          class InnerTraits = std::iterator_traits&lt;InnerIterator&gt;
         &gt;
 struct indirect_traits
 {
    typedef typename OuterTraits::difference_type difference_type;
    typedef typename InnerTraits::value_type value_type;
    typedef typename InnerTraits::pointer pointer;
    typedef typename InnerTraits::reference reference;
    typedef typename OuterTraits::iterator_category iterator_category;
 };
 </PRE></TD></TABLE>
 Lastly we wrap this up in two type generators:
 <tt>indirect_iterator</tt> for creating a single indirect iterator
 type, and <tt>indirect_iterators</tt> for creating an const/non-const
 pair of indirect iterator types. We use the <tt>iterator_adaptor</tt>
 and <tt>iterator_adaptors</tt> classes here to do most of the work.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class OuterIterator, class InnerIterator,
          class OuterTraits = std::iterator_traits&lt;OuterIterator&gt;,
          class InnerTraits = std::iterator_traits&lt;InnerIterator&gt;
         &gt;
 struct indirect_iterator
 {
    typedef iterator_adaptor&lt;OuterIterator,
        indirect_iterator_policies,
        indirect_traits&lt;OuterIterator, InnerIterator,
                        OuterTraits, InnerTraits&gt;
    &gt; type;
 };
 template &lt;class OuterIterator,      // Mutable or Immutable, does not matter
          class InnerIterator,      // Mutable
          class ConstInnerIterator, // Immutable
          class OuterTraits = std::iterator_traits&lt;OuterIterator&gt;,
          class InnerTraits = std::iterator_traits&lt;InnerIterator&gt;,
          class ConstInnerTraits = std::iterator_traits&lt;ConstInnerIterator&gt;
         &gt;
 struct indirect_iterators
 {
    typedef iterator_adaptors&lt;OuterIterator, OuterIterator,
        indirect_traits&lt;OuterIterator, InnerIterator,
                        OuterTraits, InnerTraits&gt;,
        indirect_traits&lt;OuterIterator, ConstInnerIterator,
                        OuterTraits, ConstInnerTraits&gt;,
        indirect_iterator_policies
        &gt; Adaptors;
    typedef typename Adaptors::iterator iterator;
    typedef typename Adaptors::const_iterator const_iterator;
 };
 </PRE></TD></TABLE>
 <h3><a name="projection_iterators">The Projection Iterator Adaptors</a></h3>
 The projection iterator adaptor is very similar to the transform
 iterator, except for a subtle difference in the return type: the
 tranform iterator returns the result of the unary function by value,
 whereas the projection iterator returns the result by reference.
 Therefore, these two adaptors cater to different kinds of unary
 functions. Transform iterator caters to functions that create new
 objects, whereas projection iterator caters to a function that somehow
 obtains a reference to an object that already exists. An example of a
 unary function that is suitable for use with the projection adaptor is
 <tt>select1st_</tt>:
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class Pair&gt;
 struct select1st_ 
  : public std::unary_function&lt;Pair, typename Pair::first_type&gt;
 {
  const typename Pair::first_type& operator()(const Pair& x) const {
    return x.first;
  }
  typename Pair::first_type& operator()(Pair& x) const {
    return x.first;
  }
 };
 </PRE></TD></TABLE>
 The implementation of projection iterator is as follows.  First, the
 policies class is the same as the transform iterator's policies class.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class AdaptableUnaryFunction&gt;
 struct projection_iterator_policies : public default_iterator_policies
 {
    projection_iterator_policies() { }
    projection_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
    template &lt;class Reference, class Iterator&gt;
    Reference dereference (type&lt;Reference&gt;, Iterator const& iter) const {
        return m_f(*iter);
    }
    AdaptableUnaryFunction m_f;    
 };
 </PRE></TD></TABLE>
 Next we have two traits classes. We use <tt>value_type&</tt> for the
 reference type of the mutable projection iterator, and <tt>const
 value_type&</tt> for the immutable projection iterator.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class AdaptableUnaryFunction, class Traits&gt;
 struct projection_iterator_traits {
    typedef typename AdaptableUnaryFunction::result_type value_type;
    typedef value_type& reference;
    typedef value_type* pointer;
    typedef typename Traits::difference_type difference_type;
    typedef typename Traits::iterator_category iterator_category;
 };
 template &lt;class AdaptableUnaryFunction, class Traits&gt;
 struct const_projection_iterator_traits {
    typedef typename AdaptableUnaryFunction::result_type value_type;
    typedef value_type const& reference;
    typedef value_type const* pointer;
    typedef typename Traits::difference_type difference_type;
    typedef typename Traits::iterator_category iterator_category;
 };
 </PRE></TD></TABLE>
 And to finish up, we create three generator classes that
 use <tt>iterator_adaptor</tt> to create the projection iterator
 types. The class <tt>projection_iterator</tt> creates a mutable
 projection iterator type. The class <tt>const_projection_iterator</tt>
 creates an immutable projection iterator type, and
 <tt>projection_iterators</tt> creates both mutable and immutable
 projection iterator types.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class AdaptableUnaryFunction, class Iterator,
          class Traits = std::iterator_traits&lt;Iterator&gt;
         &gt;
 struct projection_iterator {
    typedef projection_iterator_traits&lt;AdaptableUnaryFunction, Traits&gt;
            Projection_Traits;
    typedef iterator_adaptor&lt;Iterator,
            projection_iterator_policies&lt;AdaptableUnaryFunction&gt;,
            Projection_Traits&gt; type;
 };
 template &lt;class AdaptableUnaryFunction, class Iterator,
          class Traits = std::iterator_traits&lt;Iterator&gt;
         &gt;
 struct const_projection_iterator {
    typedef const_projection_iterator_traits&lt;AdaptableUnaryFunction,
            Traits&gt; Projection_Traits;
    typedef iterator_adaptor&lt;Iterator,
            projection_iterator_policies&lt;AdaptableUnaryFunction&gt;,
            Projection_Traits&gt; type;
 };
 template &lt;class AdaptableUnaryFunction, class Iterator, class ConstIterator,
          class Traits = std::iterator_traits&lt;Iterator&gt;,
          class ConstTraits = std::iterator_traits&lt;ConstIterator&gt;
         &gt;
 struct projection_iterators {
    typedef projection_iterator_traits&lt;AdaptableUnaryFunction, Traits&gt;
            Projection_Traits;
    typedef const_projection_iterator_traits&lt;AdaptableUnaryFunction,
            ConstTraits&gt; Const_Projection_Traits;
    typedef iterator_adaptors&lt;Iterator, ConstIterator,
            Projection_Traits, Const_Projection_Traits,
            projection_iterator_policies&lt;AdaptableUnaryFunction&gt; &gt; Adaptors;
    typedef typename Adaptors::iterator iterator;
    typedef typename Adaptors::const_iterator const_iterator;
 };
 </PRE></TD></TABLE>
 <h3><a name="reverse_iterators">The Reverse Iterators Class</a></h3>
 <p>
 Yes, there is already a <tt>reverse_iterator</tt> adaptor class
 defined in the C++ Standard, but using the <tt>iterator_adaptors</tt>
 class we can re-implement this classic adaptor in a more succinct and
 elegant fashion. Also, this makes for a good example of using
 <tt>iterator_adaptors</tt> that is in familiar territory.
 <p>
 The first step is to create the <tt>Policies</tt> class. As in the
 <tt>std::reverse_iterator</tt> class, we need to flip all the
 operations of the iterator. Increment will become decrement, advancing
 by <tt>n</tt> will become retreating by <tt>n</tt>, etc. 
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 struct reverse_iterator_policies
 {
  template &lt;class Reference, class Iterator&gt;
  Reference dereference(type&lt;Reference&gt;, const Iterator& x) const
    { return *boost::prior(x); }
    // this is equivalent to { Iterator tmp = x; return *--tmp; }
  template &lt;class Iterator&gt;
  void increment(Iterator& x) const
    { --x; }
  template &lt;class Iterator&gt;
  void decrement(Iterator& x) const
    { ++x; }
  template &lt;class Iterator, class DifferenceType&gt;
  void advance(Iterator& x, DifferenceType n) const
    { x -= n; }
  template &lt;class Difference, class Iterator1, class Iterator2&gt;
  Difference distance(type&lt;Difference&gt;, Iterator1& x, Iterator2& y) const
    { return x - y; }
  template &lt;class Iterator1, class Iterator2&gt;
  bool equal(Iterator1& x, Iterator2& y) const
    { return x == y; }
  template &lt;class Iterator1, class Iterator2&gt;
  bool less(Iterator1& x, Iterator2& y) const
    { return y &lt; x; }
 };
 </PRE></TD></TABLE>
 Since the traits of the reverse iterator adaptor will be the same as
 the adapted iterator's traits, we do not need to create new traits
 classes as was the case for <tt>transform_iterator</tt>. We can skip to
 the final stage of creating a type generator class for our reverse
 iterators using the <tt>iterator_adaptor</tt> class.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class Iterator, class ConstIterator,
          class Traits = std::iterator_traits&lt;Iterator&gt;, 
          class ConstTraits = std::iterator_traits&lt;ConstIterator&gt;
         &gt;
 struct reverse_iterators
 {
  typedef iterator_adaptors&lt;Iterator,ConstIterator,Traits,ConstTraits,
    reverse_iterator_policies&gt; Adaptor;
  typedef typename Adaptor::iterator iterator;
  typedef typename Adaptor::const_iterator const_iterator;
 };
 </PRE></TD></TABLE>
 A typical use of the <tt>reverse_iterators</tt> class is in
 user-defined container types. You can use the
 <tt>reverse_iterators</tt> class to generate the reverse iterators for
 your container.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 class my_container {
  ...
  typedef ... iterator;
  typedef ... const_iterator;
  typedef reverse_iterators&lt;iterator, const_iterator&gt; RevIters;
  typedef typename RevIters::iterator reverse_iterator;
  typedef typename RevIters::const_iterator const_reverse_iterator;
  ...
 };
 </PRE></TD></TABLE>
 <h3><a name="integer_range">The Integer Range Class</a></h3>
 The <tt>iterator_adaptors</tt> class can not only be used for adapting
 iterators, but it can also be used to take a non-iterator type and use
 it to build an iterator. An especially simple example of this is
 turning an integer type into an iterator, a counting iterator. The
 builtin integer types of C++ are almost iterators. They have
 <tt>operator++()</tt>, <tt>operator--()</tt>, etc. The one operator
 they are lacking is the <tt>operator*()</tt>, which we will want to
 simply return the current value of the integer. The following few
 lines of code implement the policy and traits class for the counting
 iterator.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class IntegerType&gt;
 struct counting_iterator_policies : public default_iterator_policies
 {
  IntegerType dereference(type&lt;IntegerType&gt;, const IntegerType& i) const
    { return i; }
 };
 template &lt;class IntegerType&gt;
 struct counting_iterator_traits {
  typedef IntegerType value_type;
  typedef IntegerType reference;
  typedef value_type* pointer;
  typedef std::ptrdiff_t difference_type;
  typedef std::random_access_iterator_tag iterator_category;
 };
 </PRE></TD></TABLE>
 Typically we will want to count the integers in some range, so a nice
 interface would be to have a fake container that represents the range
 of integers. The following is the definition of such a class called
 <tt>integer_range</tt>.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 template &lt;class IntegerType&gt;
 struct integer_range {
  typedef typename iterator_adaptor&lt;IntegerType, 
                           counting_iterator_traits&lt;IntegerType&gt;,
                           counting_iterator_policies &gt;::type iterator;
  typedef iterator const_iterator;
  typedef IntegerType value_type;
  typedef std::ptrdiff_t difference_type;
  typedef IntegerType reference;
  typedef IntegerType* pointer;
  typedef IntegerType size_type;
  integer_range(IntegerType start, IntegerType finish)
    : m_start(start), m_finish(finish) { }
  iterator begin() const { return iterator(m_start); }
  iterator end() const { return iterator(m_finish); }
  size_type size() const { return m_finish - m_start; }
  bool empty() const { return m_finish == m_start; }
  void swap(integer_range& x) {
    std::swap(m_start, x.m_start);
    std::swap(m_finish, x.m_finish);
  }
 protected:
  IntegerType m_start, m_finish;
 };
 </PRE></TD></TABLE>
 <p>
 The following is an example of how to use the
 <tt>integer_range</tt> class to count from 0 to 4.
 <p>
 <TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
 <TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
 <PRE>
 boost::integer_range&lt;int&gt; r(0,5);
 cout &lt;&lt; "counting to from 0 to 4:" &lt;&lt; endl;
 std::copy(r.begin(), r.end(), ostream_iterator&lt;int&gt;(cout, " "));
 cout &lt;&lt; endl;
 </PRE></TD></TABLE>
 <h3>Challenge</h3>
 <p>
 There is an unlimited number of ways the the
 <tt>iterator_adaptors</tt> class can be used to create iterators. One
 interesting exercise would be to re-implement the iterators of
 <tt>std::list</tt> and <tt>std::slist</tt> using
 <tt>iterator_adaptors</tt>, where the adapted <tt>Iterator</tt> types
 would be node pointers.
 <h3>Notes</h3>
 <p>
 <a name="1">[1]</a>
 If your compiler does not support partial specialization and hence
 does not have a working <tt>std::iterator_traits</tt> class, you will
 not be able to use the defaults and will need to supply your own
 <tt>Traits</tt> and <tt>ConstTraits</tt> classes.
 <p>
 <a name="2">[2]</a>
 The reference type could also be obtained from
 <tt>std::iterator_traits</tt>, but that is not portable on compilers
 that do not support partial specialization.
 <p>
 <a name="3">[3]</a>
 It would have been more elegant to implement <tt>indirect_iterators</tt>
 using <tt>transform_iterators</tt>, but for subtle reasons that would require
 the use of <tt>boost::remove_cv</tt> which is not portable.
 <h3>Implementation Notes</h3>
 The code is somewhat complicated because there are three iterator
 adaptor class: <tt>forward_iterator_adaptor</tt>,
 <tt>bidirectional_iterator_adaptor</tt>, and
 <tt>random_access_iterator_adaptor</tt>. The alternative would be to
 just have one iterator adaptor equivalent to the
 <tt>random_access_iterator_adaptor</tt>.  The reason for going with
 the three adaptors is that according to 14.5.3p5 in the C++ Standard,
 friend functions defined inside a template class body are instantiated
 when the template class is instantiated. This means that if we only
 used the one iterator adaptor, then if the adapted iterator did not
 meet all of the requirements for a
 <a href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html">
 RandomAccessIterator</a> then a compiler error should occur.  Many
 current compilers in fact do not instantiate the friend functions
 unless used, so we could get away with the one iterator adaptor in
 most cases. However, out of respect for the standard this implementation
 uses the three adaptors.
 <hr>
 <p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->27 Nov 2000<!--webbot bot="Timestamp" endspan i-checksum="15248" --></p>
 <p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
 modify, sell and distribute this document is granted provided this copyright
 notice appears in all copies. This document is provided &quot;as is&quot;
 without express or implied warranty, and with no claim as to its suitability for
 any purpose.</p>
 </body>
 </html>
--- a/operators.htm
+++ b/operators.htm
@@ -0,0 +1,597 @@
 <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="../../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="../../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="../../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="../../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 -->27 Sep 2000<!--webbot bot="Timestamp" endspan i-checksum="14936" --></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
@@ -0,0 +1,137 @@
 <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" width="277" height="86"> 
 <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 std::pair&lt;&gt;. 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="../graph/doc/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 operations 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; &quot; was already in the set.&quot; &lt;&lt; std::endl;
      else
        std::cout &lt;&lt; *i &lt;&lt; &quot; successfully inserted.&quot; &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; &quot;There were &quot; &lt;&lt; std::distance(i,end)
              &lt;&lt; &quot; occurrences of &quot; &lt;&lt; *i &lt;&lt; &quot;.&quot; &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 occurrences 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
@@ -0,0 +1,61 @@
 //  (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
@@ -0,0 +1,620 @@
 <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%">&nbsp; </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%">&nbsp; </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%">&nbsp; </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%">&nbsp; </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%">&nbsp; </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%">&nbsp; </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 01 September 2000</p>
 <p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
 sell and distribute this document is granted provided this
 copyright notice appears in all copies. This document is provided
 &quot;as is&quot; without express or implied warranty, and with
 no claim as to its suitability for any purpose.</p>
 <p>Based on contributions by Steve Cleary, Beman Dawes, Howard
 Hinnant and John Maddock.</p>
 <p>Maintained by <a href="mailto:John_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,7 +4,11 @@
 //  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
@@ -16,36 +20,11 @@
 #include <typeinfo>
 #include <boost/type_traits.hpp>
 #include <boost/utility.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
@@ -159,6 +138,50 @@ 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(){};
 };
 //
 // struct non_pointer:
 // used to verify that is_pointer does not return
 // true for class types that implement operator void*()
 //
 struct non_pointer
 {
   operator void*(){return this;}
 };
 //
 // struct non_empty:
 // used to verify that is_empty does not emit
 // spurious warnings or errors.
 //
 struct non_empty : boost::noncopyable
 {
   int i;
 };
 // 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
@@ -215,6 +238,8 @@ int main()
   value_test(false, (is_same<int*, const int*>::value))
   value_test(false, (is_same<int*, int*const>::value))
   value_test(false, (is_same<int, int[2]>::value))
   value_test(false, (is_same<int*, int[2]>::value))
   value_test(false, (is_same<int[4], int[2]>::value))
   value_test(false, is_const<int>::value)
   value_test(true, is_const<const int>::value)
@@ -358,9 +383,14 @@ int main()
   value_test(false, is_array<int>::value)
   value_test(false, is_array<int*>::value)
   value_test(false, is_array<const int*>::value)
   value_test(false, is_array<const volatile int*>::value)
   value_test(true, is_array<int[2]>::value)
   value_test(true, is_array<const int[2]>::value)
   value_test(true, is_array<const volatile int[2]>::value)
   value_test(true, is_array<int[2][3]>::value)
   value_test(true, is_array<UDT[2]>::value)
   value_test(false, is_array<int(&)[2]>::value)
   typedef void(*f1)();
   typedef int(*f2)(int);
@@ -370,15 +400,28 @@ int main()
   typedef int (UDT::*mf3)(int);
   typedef int (UDT::*mf4)(int, float);
   value_test(false, is_const<f1>::value)
   value_test(false, is_reference<f1>::value)
   value_test(false, is_array<f1>::value)
   value_test(false, is_pointer<int>::value)
   value_test(false, is_pointer<int&>::value)
   value_test(true, is_pointer<int*>::value)
   value_test(true, is_pointer<const int*>::value)
   value_test(true, is_pointer<volatile int*>::value)
   value_test(true, is_pointer<non_pointer*>::value)
   // Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
   value_test(false, is_pointer<int*const>::value)
   // Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
   value_test(false, is_pointer<int*volatile>::value)
   // Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
   value_test(false, is_pointer<int*const volatile>::value)
   // JM 02 Oct 2000:
   value_test(false, is_pointer<non_pointer>::value)
   value_test(false, is_pointer<int*&>::value)
   value_test(false, is_pointer<int(&)[2]>::value)
   value_test(false, is_pointer<int[2]>::value)
   value_test(false, is_pointer<char[sizeof(void*)]>::value)
   value_test(true, is_pointer<f1>::value)
   value_test(true, is_pointer<f2>::value)
   value_test(true, is_pointer<f3>::value)
@@ -397,6 +440,7 @@ int main()
   value_test(true, is_reference<volatile int &>::value)
   value_test(true, is_reference<r_type>::value)
   value_test(true, is_reference<cr_type>::value)
   value_test(true, is_reference<const UDT&>::value)
   value_test(false, is_class<int>::value)
   value_test(false, is_class<const int>::value)
@@ -438,14 +482,29 @@ int main()
   value_test(false, is_empty<int>::value)
   value_test(false, is_empty<int*>::value)
   value_test(false, is_empty<int&>::value)
 #if defined(__MWERKS__) || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   // 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
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   value_fail(false, is_empty<f1>::value)
 #else
   value_test(false, is_empty<f1>::value)
 #endif
   value_test(false, is_empty<mf1>::value)
   value_test(false, is_empty<UDT>::value)
   value_test(true, is_empty<empty_UDT>::value)
   value_test(true, is_empty<empty_POD_UDT>::value)
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   value_fail(true, is_empty<empty_union_UDT>::value)
 #else
   value_test(true, is_empty<empty_union_UDT>::value)
 #endif
   value_test(false, is_empty<enum_UDT>::value)
   value_test(true, is_empty<boost::noncopyable>::value)
   value_test(false, is_empty<non_empty>::value)
   value_test(true, has_trivial_constructor<int>::value)
   value_test(true, has_trivial_constructor<int*>::value)
@@ -524,6 +583,57 @@ 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, int>::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(true, (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
@@ -0,0 +1,112 @@
 // 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 )
 #ifdef BOOST_MSVC
 #define value_test(v, x) ++test_count;\
                        {typedef ct_checker<(x)> this_is_a_compile_time_check_;}\
                         if(!do_compare((int)v,(int)x)){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
 #else
 #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;}
 #endif
 #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
@@ -0,0 +1,104 @@
 <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>Function templates <a href="#functions next">next() and prior()</a></li>
  <li>Class <a href="#Class noncopyable">noncopyable</a></li>
  <li>Function template <a href="tie.html">tie()</a> and supporting class tied.</li>
 </ul>
 <h2> <a name="functions next">Function</a> templates next() 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
 -->28 September, 2000<!--webbot bot="Timestamp" endspan i-checksum="39343"
 -->
 </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
nobody	e7940ce7bf	This commit was manufactured by cvs2svn to create tag 'Version_1_20_1'. [SVN r8548]	2001-01-10 18:29:12 +00:00
John Maddock	f694e557e1	compressed pair fixes for VC6 [SVN r8543]	2001-01-10 12:21:30 +00:00
Beman Dawes	6a0c3e92a0	Initial commit after public review (note change in library name per review) [SVN r8516]	2001-01-06 16:47:36 +00:00
John Maddock	cba48df8e3	VC6 fixes for compressed_pair [SVN r8485]	2000-12-21 12:27:22 +00:00
Jeremy Siek	a0e8d1bf36	a C++ standard version of LessThanComparable [SVN r8435]	2000-12-09 22:39:50 +00:00
Jeremy Siek	912dedaca7	added #include boost/config.hpp at top to remove truncation warning on VC++ [SVN r8434]	2000-12-09 20:28:48 +00:00
Beman Dawes	7dd90c3919	CVS says it needs a commit; who knows why? [SVN r8405]	2000-12-08 17:35:43 +00:00
Jeremy Siek	7c3a25a377	various changes, almost forgot to check in [SVN r8379]	2000-12-03 06:20:23 +00:00
Jeremy Siek	c8fbca2d44	added docs for projection iterator [SVN r8322]	2000-11-24 21:31:43 +00:00
Jeremy Siek	f7ed0aaeed	added std:: to unary_function [SVN r8321]	2000-11-24 20:48:02 +00:00
Jeremy Siek	6e78270140	added projection iterator to the test [SVN r8320]	2000-11-24 20:45:26 +00:00
Jeremy Siek	ba354377d5	updated docs for indirect iterators [SVN r8319]	2000-11-24 20:22:23 +00:00
Jeremy Siek	353c030918	simplified version of iterator_adaptor, plus fix to indirect iterator and addition of projection iterator [SVN r8317]	2000-11-24 19:40:51 +00:00
John Maddock	331a2b8282	Fixed regex memory leak, and type_traits bad test case [SVN r8273]	2000-11-21 12:39:09 +00:00
Jeremy Siek	4bd6909ea1	* empty log message * [SVN r8158]	2000-11-07 23:05:04 +00:00
John Maddock	26119613e1	BeOS5 (intel) fixes [SVN r8133]	2000-11-04 11:16:12 +00:00
Beman Dawes	45bfe0b607	HTML change for 1.18.2 reflecting separation of old utility library [SVN r8118]	2000-11-03 19:22:26 +00:00
Jeremy Siek	ce2f573ab2	new file, based on the C++ standard, not SGI STL's definition of Assignable [SVN r8062]	2000-10-29 21:35:59 +00:00
John Maddock	66d5cc43f3	added BeOS5 support to test script (not finished yet though...) [SVN r8037]	2000-10-28 10:54:12 +00:00
Dave Abrahams	e8265e09a3	Add trivial numeric_cast tests for floating types. [SVN r8007]	2000-10-19 19:12:53 +00:00
Beman Dawes	860cf0b321	Fix broken HTML links [SVN r7951]	2000-10-15 17:08:00 +00:00
John Maddock	89c74708d7	misc minor fixes [SVN r7938]	2000-10-14 12:03:10 +00:00
Beman Dawes	74c8680350	Add missing "typename" that Metrowerks compiler is picky about [SVN r7929]	2000-10-12 21:01:49 +00:00
John Maddock	3cd9f5b623	MWCW fix: added std:: qualifier to memset [SVN r7923]	2000-10-10 11:40:19 +00:00
John Maddock	0936110741	minor typo fixes [SVN r7922]	2000-10-10 10:40:58 +00:00
John Maddock	6161ce15c7	more VC6 type-traits and compressed pair fixes [SVN r7921]	2000-10-07 10:53:47 +00:00
John Maddock	28594a22f1	More VC6 fixes for is_pointer/is_array/is_same [SVN r7896]	2000-10-03 11:53:39 +00:00
John Maddock	656517b059	More VC6 fixes for compressed_pair and type_traits. [SVN r7895]	2000-10-03 11:47:24 +00:00
Dave Abrahams	ad576863b4	fix typo: compressed_pait->compressed_pair [SVN r7894]	2000-10-03 08:06:19 +00:00
John Maddock	775be75366	updated call_traits and type_traits test programs for VC6 [SVN r7883]	2000-10-01 11:57:00 +00:00
John Maddock	7ae6e5bac9	call_traits and type_traits updates for VC6 [SVN r7882]	2000-10-01 11:48:27 +00:00
Beman Dawes	c5915c23e7	Fix broken link [SVN r7870]	2000-09-28 17:47:29 +00:00
Beman Dawes	1f2a827df3	Integrate Tie with other HTML files [SVN r7866]	2000-09-28 12:35:46 +00:00
Beman Dawes	f51ee4ef2e	Initial Graph and Regex HTML integration [SVN r7849]	2000-09-26 19:02:50 +00:00
Jeremy Siek	75aadf0509	removed tabs [SVN r7835]	2000-09-25 21:19:29 +00:00
Jeremy Siek	4f9b0bcb9b	disabled warning about operator-> not returning a UDT. If operator-> does not get called, it should not be checked for this error. This showed up when using an iterator with value_type=int. [SVN r7813]	2000-09-25 05:36:21 +00:00
Beman Dawes	9628e5adb0	Fix broken links [SVN r7770]	2000-09-22 18:09:04 +00:00
Jeremy Siek	b5418034ff	some new docs, and more documentation edits [SVN r7746]	2000-09-19 18:40:30 +00:00
Jeremy Siek	6dda4704e1	more documentation editing [SVN r7725]	2000-09-18 17:17:44 +00:00
Jeremy Siek	79c360a1d8	new file [SVN r7722]	2000-09-18 16:03:04 +00:00
Jeremy Siek	b70ad177bb	new documentation [SVN r7721]	2000-09-18 16:00:39 +00:00
Jeremy Siek	7b02fdb1d9	added #include <utility> because tied uses std::pair [SVN r7714]	2000-09-18 09:25:18 +00:00
Jeremy Siek	73acec35c9	added tied() [SVN r7705]	2000-09-18 08:27:37 +00:00
John Maddock	3ddb9abc3c	Updates to cope with Borland C++ 5.51 [SVN r7697]	2000-09-09 10:20:24 +00:00
Beman Dawes	5b06dd0d0d	1.17.0 release candidate runup [SVN r7683]	2000-08-03 15:26:16 +00:00
John Maddock	daf7829ffa	type traits update [added is_convertible and alignment_of] [SVN r7675]	2000-08-02 10:58:59 +00:00
John Maddock	2086542bfb	replaced lost copyright declaration [SVN r7662]	2000-07-30 10:33:53 +00:00
John Maddock	e52916acf2	minor compiler compatability fixes [SVN r7661]	2000-07-29 11:39:42 +00:00
Beman Dawes	767b61a254	Minor format fix [SVN r7647]	2000-07-27 14:46:43 +00:00
Beman Dawes	ba62287576	Initial commit [SVN r7646]	2000-07-27 14:46:23 +00:00
Beman Dawes	b231894f1b	Test HTML commit after FrontPage change. No actual content changed. [SVN r7639]	2000-07-27 14:21:30 +00:00
Beman Dawes	d83ea9e52e	Initial HTML commit [SVN r7634]	2000-07-27 13:38:51 +00:00
Beman Dawes	777c931b5d	Initial version from John Maddock [SVN r7631]	2000-07-26 17:29:19 +00:00