This commit was manufactured by cvs2svn to create tag

'Version_1_21_1'. [SVN r9561]
1.21.0 run up including fixing broken links
2025-10-05 21:40:59 +02:00 · 2001-03-14 15:36:54 +00:00 · 2001-03-09 14:36:41 +00:00 · 2001-03-09 03:28:13 +00:00 · 2001-03-09 03:10:32 +00:00 · 2001-03-08 21:36:09 +00:00
51 changed files with 6908 additions and 2715 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
@@ -1,423 +0,0 @@
-
-/*
- *
- * Copyright (c) 1999
- * Dr John Maddock
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation.  Dr John Maddock makes no representations
- * about the suitability of this software for any purpose.
- * It is provided "as is" without express or implied warranty.
- *
- * This file provides some example of type_traits usage -
- * by "optimising" various algorithms:
- *
- * opt::copy - optimised for trivial copy (cf std::copy)
- * opt::fill - optimised for trivial copy/small types (cf std::fill)
- * opt::destroy_array - an example of optimisation based upon omitted destructor calls
- * opt::iter_swap - uses type_traits to determine whether the iterator is a proxy
- *                  in which case it uses a "safe" approach, otherwise calls swap
- *                  on the assumption that swap may be specialised for the pointed-to type.
- *
- */
-
-/* Release notes:
-   23rd July 2000:
-      Added explicit failure for broken compilers that don't support these examples.
-      Fixed broken gcc support (broken using directive).
-      Reordered tests slightly.
-*/
-
-#include <iostream>
-#include <typeinfo>
-#include <algorithm>
-#include <iterator>
-#include <vector>
-#include <memory>
-
-#include <boost/timer.hpp>
-#include <boost/type_traits.hpp>
-#include <boost/call_traits.hpp>
-
-using std::cout;
-using std::endl;
-using std::cin;
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#error "Sorry, without template partial specialisation support there isn't anything to test here..."
-#endif
-
-namespace opt{
-
-//
-// algorithm destroy_array:
-// The reverse of std::unitialized_copy, takes a block of
-// unitialized memory and calls destructors on all objects therein.
-//
-
-namespace detail{
-
-template <bool>
-struct array_destroyer
-{
-   template <class T>
-   static void destroy_array(T* i, T* j){ do_destroy_array(i, j); }
-};
-
-template <>
-struct array_destroyer<true>
-{
-   template <class T>
-   static void destroy_array(T*, T*){}
-};
-
-template <class T>
-void do_destroy_array(T* first, T* last)
-{
-   while(first != last)
-   {
-      first->~T();
-      ++first;
-   }
-}
-
-}; // namespace detail
-
-template <class T>
-inline void destroy_array(T* p1, T* p2)
-{
-   detail::array_destroyer<boost::has_trivial_destructor<T>::value>::destroy_array(p1, p2);
-}
-
-//
-// unoptimised versions of destroy_array:
-//
-template <class T>
-void destroy_array1(T* first, T* last)
-{
-   while(first != last)
-   {
-      first->~T();
-      ++first;
-   }
-}
-template <class T>
-void destroy_array2(T* first, T* last)
-{
-   for(; first != last; ++first) first->~T();
-}
-
-
-//
-// opt::copy
-// same semantics as std::copy
-// calls memcpy where appropiate.
-//
-
-namespace detail{
-
-template <bool b>
-struct copier
-{
-   template<typename I1, typename I2>
-   static I2 do_copy(I1 first, I1 last, I2 out);
-};
-
-template <bool b>
-template<typename I1, typename I2>
-I2 copier<b>::do_copy(I1 first, I1 last, I2 out)
-{
-   while(first != last)
-   {
-      *out = *first;
-      ++out;
-      ++first;
-   }
-   return out;
-}
-
-template <>
-struct copier<true>
-{
-   template<typename I1, typename I2>
-   static I2* do_copy(I1* first, I1* last, I2* out)
-   {
-      memcpy(out, first, (last-first)*sizeof(I2));
-      return out+(last-first);
-   }
-};
-
-
-}
-
-template<typename I1, typename I2>
-inline I2 copy(I1 first, I1 last, I2 out)
-{
-   typedef typename boost::remove_cv<typename std::iterator_traits<I1>::value_type>::type v1_t;
-   typedef typename boost::remove_cv<typename std::iterator_traits<I2>::value_type>::type v2_t;
-   enum{ can_opt = boost::is_same<v1_t, v2_t>::value
-                   && boost::is_pointer<I1>::value
-                   && boost::is_pointer<I2>::value
-                   && boost::has_trivial_assign<v1_t>::value };
-   return detail::copier<can_opt>::do_copy(first, last, out);
-}
-
-//
-// fill
-// same as std::fill, uses memset where appropriate, along with call_traits
-// to "optimise" parameter passing.
-//
-namespace detail{
-
-template <bool opt>
-struct filler
-{
-   template <typename I, typename T>
-   static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val);
- };
-
-template <bool b>
-template <typename I, typename T>
-void filler<b>::do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
-{
-   while(first != last)
-   {
-      *first = val;
-      ++first;
-   }
-}
-
-template <>
-struct filler<true>
-{
-   template <typename I, typename T>
-   static void do_fill(I first, I last, T val)
-   {
-      memset(first, val, last-first);
-   }
-};
-
-}
-
-template <class I, class T>
-inline void fill(I first, I last, const T& val)
-{
-   enum{ can_opt = boost::is_pointer<I>::value
-                   && boost::is_arithmetic<T>::value
-                   && (sizeof(T) == 1) };
-   typedef detail::filler<can_opt> filler_t;
-   filler_t::template do_fill<I,T>(first, last, val);
-}
-
-//
-// iter_swap:
-// tests whether iterator is a proxying iterator or not, and
-// uses optimal form accordingly:
-//
-namespace detail{
-
-template <bool b>
-struct swapper
-{
-   template <typename I>
-   static void do_swap(I one, I two)
-   {
-      typedef typename std::iterator_traits<I>::value_type v_t;
-      v_t v = *one;
-      *one = *two;
-      *two = v;
-   }
-};
-
-#ifdef __GNUC__
-using std::swap;
-#endif
-
-template <>
-struct swapper<true>
-{
-   template <typename I>
-   static void do_swap(I one, I two)
-   {
-      using std::swap;
-      swap(*one, *two);
-   }
-};
-
-}
-
-template <typename I1, typename I2>
-inline void iter_swap(I1 one, I2 two)
-{
-   typedef typename std::iterator_traits<I1>::reference r1_t;
-   typedef typename std::iterator_traits<I2>::reference r2_t;
-   enum{ can_opt = boost::is_reference<r1_t>::value && boost::is_reference<r2_t>::value && boost::is_same<r1_t, r2_t>::value };
-   detail::swapper<can_opt>::do_swap(one, two);
-}
-
-
-};   // namespace opt
-
-//
-// define some global data:
-//
-const int array_size = 1000;
-int i_array[array_size] = {0,};
-const int ci_array[array_size] = {0,};
-char c_array[array_size] = {0,};
-const char cc_array[array_size] = { 0,};
-
-const int iter_count = 1000000;
-
-
-int main()
-{
-   //
-   // test destroy_array,
-   // compare destruction time of an array of ints
-   // with unoptimised form.
-   //
-   cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
-   cout << "testing destroy_array...\n"
-    "[Some compilers may be able to optimise the \"unoptimised\"\n versions as well as type_traits does.]" << endl;
-   /*cache load*/ opt::destroy_array(i_array, i_array + array_size);
-   boost::timer t;
-   double result;
-   int i;
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::destroy_array(i_array, i_array + array_size);
-   }
-   result = t.elapsed();
-   cout << "destroy_array<int>: " << result << endl;
-   /*cache load*/ opt::destroy_array1(i_array, i_array + array_size);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::destroy_array1(i_array, i_array + array_size);
-   }
-   result = t.elapsed();
-   cout << "destroy_array<int>(unoptimised#1): " << result << endl;
-   /*cache load*/ opt::destroy_array2(i_array, i_array + array_size);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::destroy_array2(i_array, i_array + array_size);
-   }
-   result = t.elapsed();
-   cout << "destroy_array<int>(unoptimised#2): " << result << endl << endl;
-
-   cout << "testing fill(char)...\n"
-   "[Some standard library versions may already perform this optimisation.]" << endl;
-   /*cache load*/ opt::fill<char*, char>(c_array, c_array + array_size, (char)3);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::fill<char*, char>(c_array, c_array + array_size, (char)3);
-   }
-   result = t.elapsed();
-   cout << "opt::fill<char*, char>: " << result << endl;
-   /*cache load*/ std::fill(c_array, c_array + array_size, (char)3);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::fill(c_array, c_array + array_size, (char)3);
-   }
-   result = t.elapsed();
-   cout << "std::fill<char*, char>: " << result << endl << endl;
-
-   cout << "testing fill(int)...\n"
-   "[Tests the effect of call_traits pass-by-value optimisation -\nthe value of this optimisation may depend upon hardware characteristics.]" << endl;
-   /*cache load*/ opt::fill<int*, int>(i_array, i_array + array_size, 3);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::fill<int*, int>(i_array, i_array + array_size, 3);
-   }
-   result = t.elapsed();
-   cout << "opt::fill<int*, int>: " << result << endl;
-   /*cache load*/ std::fill(i_array, i_array + array_size, 3);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::fill(i_array, i_array + array_size, 3);
-   }
-   result = t.elapsed();
-   cout << "std::fill<int*, int>: " << result << endl << endl;
-
-   cout << "testing copy...\n"
-   "[Some standard library versions may already perform this optimisation.]" << endl;
-   /*cache load*/ opt::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "opt::copy<const int*, int*>: " << result << endl;
-   /*cache load*/ std::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "std::copy<const int*, int*>: " << result << endl;
-   /*cache load*/ opt::detail::copier<false>::template do_copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::detail::copier<false>::template do_copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
-   }
-   result = t.elapsed();
-   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
-
-   /*cache load*/ opt::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "opt::copy<const char*, char*>: " << result << endl;
-   /*cache load*/ std::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      std::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "std::copy<const char*, char*>: " << result << endl;
-   /*cache load*/ opt::detail::copier<false>::template do_copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   t.restart();
-   for(i = 0; i < iter_count; ++i)
-   {
-      opt::detail::copier<false>::template do_copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
-   }
-   result = t.elapsed();
-   cout << "standard \"unoptimised\" copy: " << result << endl << endl;
-
-
-   //
-   // testing iter_swap
-   // really just a check that it does in fact compile...
-   std::vector<int> v1;
-   v1.push_back(0);
-   v1.push_back(1);
-   std::vector<bool> v2;
-   v2.push_back(0);
-   v2.push_back(1);
-   opt::iter_swap(v1.begin(), v1.begin()+1);
-   opt::iter_swap(v2.begin(), v2.begin()+1);
-
-   cout << "Press any key to exit...";
-   cin.get();
-}
-
-
-
-
-
--- a/c++_type_traits.htm
+++ b/c++_type_traits.htm
@@ -1,489 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<title>C++ Type traits</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<h2 align="center">C++ Type traits</h2>
-<p align="center"><em>by John Maddock and Steve Cleary</em></p>
-<p align="center"><em>This is a draft of an article that will appear in a future
-issue of </em><a href="http://www.ddj.com"><em>Dr Dobb's Journal</em></a></p>
-<p>Generic programming (writing code which works with any data type meeting a
-set of requirements) has become the method of choice for providing reusable
-code. However, there are times in generic programming when &quot;generic&quot;
-just isn't good enough - sometimes the differences between types are too large
-for an efficient generic implementation. This is when the traits technique
-becomes important - by encapsulating those properties that need to be considered
-on a type by type basis inside a traits class, we can minimise the amount of
-code that has to differ from one type to another, and maximise the amount of
-generic code.</p>
-<p>Consider an example: when working with character strings, one common
-operation is to determine the length of a null terminated string. Clearly it's
-possible to write generic code that can do this, but it turns out that there are
-much more efficient methods available: for example, the C library functions <font size="2" face="Courier New">strlen</font>
-and <font size="2" face="Courier New">wcslen</font> are usually written in
-assembler, and with suitable hardware support can be considerably faster than a
-generic version written in C++. The authors of the C++ standard library realised
-this, and abstracted the properties of <font size="2" face="Courier New">char</font>
-and <font size="2" face="Courier New">wchar_t</font> into the class <font size="2" face="Courier New">char_traits</font>.
-Generic code that works with character strings can simply use <font size="2" face="Courier New">char_traits&lt;&gt;::length</font>
-to determine the length of a null terminated string, safe in the knowledge that
-specialisations of <font size="2" face="Courier New">char_traits</font> will use
-the most appropriate method available to them.</p>
-<h4>Type traits</h4>
-<p>Class <font size="2" face="Courier New">char_traits</font> is a classic
-example of a collection of type specific properties wrapped up in a single class
- what Nathan Myers termed a <i>baggage class</i>[1]. In the Boost type-traits
-library, we[2] have written a set of very specific traits classes, each of which
-encapsulate a single trait from the C++ type system; for example, is a type a
-pointer or a reference type? Or does a type have a trivial constructor, or a
-const-qualifier? The type-traits classes share a unified design: each class has
-a single member <i>value</i>, a compile-time constant that is true if the type
-has the specified property, and false otherwise. As we will show, these classes
-can be used in generic programming to determine the properties of a given type
-and introduce optimisations that are appropriate for that case.</p>
-<p>The type-traits library also contains a set of classes that perform a
-specific transformation on a type; for example, they can remove a top-level
-const or volatile qualifier from a type. Each class that performs a
-transformation defines a single typedef-member <i>type</i> that is the result of
-the transformation. All of the type-traits classes are defined inside namespace <font size="2" face="Courier New">boost</font>;
-for brevity, namespace-qualification is omitted in most of the code samples
-given.</p>
-<h4>Implementation</h4>
-<p>There are far too many separate classes contained in the type-traits library
-to give a full implementation here - see the source code in the Boost library
-for the full details - however, most of the implementation is fairly repetitive
-anyway, so here we will just give you a flavour for how some of the classes are
-implemented. Beginning with possibly the simplest class in the library, is_void&lt;T&gt;
-has a member <i>value</i> that is true only if T is void.</p>
-<pre>template &lt;typename T&gt; 
-struct is_void
-{ static const bool value = false; };
-
-template &lt;&gt; 
-struct is_void&lt;void&gt;
-{ static const bool value = true; };</pre>
-<p>Here we define a primary version of the template class <font size="2" face="Courier New">is_void</font>,
-and provide a full-specialisation when T is void. While full specialisation of a
-template class is an important technique, sometimes we need a solution that is
-halfway between a fully generic solution, and a full specialisation. This is
-exactly the situation for which the standards committee defined partial
-template-class specialisation. As an example, consider the class
-boost::is_pointer&lt;T&gt;: here we needed a primary version that handles all
-the cases where T is not a pointer, and a partial specialisation to handle all
-the cases where T is a pointer:</p>
-<pre>template &lt;typename T&gt; 
-struct is_pointer 
-{ static const bool value = false; };
-
-template &lt;typename T&gt; 
-struct is_pointer&lt;T*&gt; 
-{ static const bool value = true; };</pre>
-<p>The syntax for partial specialisation is somewhat arcane and could easily
-occupy an article in its own right; like full specialisation, in order to write
-a partial specialisation for a class, you must first declare the primary
-template. The partial specialisation contains an extra &lt;<EFBFBD>&gt; after the
-class name that contains the partial specialisation parameters; these define the
-types that will bind to that partial specialisation rather than the default
-template. The rules for what can appear in a partial specialisation are somewhat
-convoluted, but as a rule of thumb if you can legally write two function
-overloads of the form:</p>
-<pre>void foo(T);
-void foo(U);</pre>
-<p>Then you can also write a partial specialisation of the form:</p>
-<pre>template &lt;typename T&gt;
-class c{ /*details*/ };
-
-template &lt;typename T&gt;
-
-class c&lt;U&gt;{ /*details*/ };</pre>
-<p>This rule is by no means foolproof, but it is reasonably simple to remember
-and close enough to the actual rule to be useful for everyday use.</p>
-<p>As a more complex example of partial specialisation consider the class
-remove_bounds&lt;T&gt;. This class defines a single typedef-member <i>type</i>
-that is the same type as T but with any top-level array bounds removed; this is
-an example of a traits class that performs a transformation on a type:</p>
-<pre>template &lt;typename T&gt; 
-struct remove_bounds
-{ typedef T type; };
-
-template &lt;typename T, std::size_t N&gt; 
-struct remove_bounds&lt;T[N]&gt;
-{ typedef T type; };</pre>
-<p>The aim of remove_bounds is this: imagine a generic algorithm that is passed
-an array type as a template parameter, <font size="2" face="Courier New">remove_bounds</font>
-provides a means of determining the underlying type of the array. For example <code>remove_bounds&lt;int[4][5]&gt;::type</code>
-would evaluate to the type <code>int[5]</code>. This example also shows that the
-number of template parameters in a partial specialisation does not have to match
-the number in the default template. However, the number of parameters that
-appear after the class name do have to match the number and type of the
-parameters in the default template.</p>
-<h4>Optimised copy</h4>
-<p>As an example of how the type traits classes can be used, consider the
-standard library algorithm copy:</p>
-<pre>template&lt;typename Iter1, typename Iter2&gt;
-Iter2 copy(Iter1 first, Iter1 last, Iter2 out);</pre>
-<p>Obviously, there's no problem writing a generic version of copy that works
-for all iterator types Iter1 and Iter2; however, there are some circumstances
-when the copy operation can best be performed by a call to <font size="2" face="Courier New">memcpy</font>.
-In order to implement copy in terms of <font size="2" face="Courier New">memcpy</font>
-all of the following conditions need to be met:</p>
-<ul>
-  <li>Both of the iterator types Iter1 and Iter2 must be pointers.</li>
-  <li>Both Iter1 and Iter2 must point to the same type - excluding <font size="2" face="Courier New">const</font>
-    and <font size="2" face="Courier New">volatile</font>-qualifiers.</li>
-  <li>The type pointed to by Iter1 must have a trivial assignment operator.</li>
-</ul>
-<p>By trivial assignment operator we mean that the type is either a scalar
-type[3] or:</p>
-<ul>
-  <li>The type has no user defined assignment operator.</li>
-  <li>The type does not have any data members that are references.</li>
-  <li>All base classes, and all data member objects must have trivial assignment
-    operators.</li>
-</ul>
-<p>If all these conditions are met then a type can be copied using <font size="2" face="Courier New">memcpy</font>
-rather than using a compiler generated assignment operator. The type-traits
-library provides a class <i>has_trivial_assign</i>, such that <code>has_trivial_assign&lt;T&gt;::value</code>
-is true only if T has a trivial assignment operator. This class &quot;just
-works&quot; for scalar types, but has to be explicitly specialised for
-class/struct types that also happen to have a trivial assignment operator. In
-other words if <i>has_trivial_assign</i> gives the wrong answer, it will give
-the &quot;safe&quot; wrong answer - that trivial assignment is not allowable.</p>
-<p>The code for an optimised version of copy that uses <font size="2" face="Courier New">memcpy</font>
-where appropriate is given in listing 1. The code begins by defining a template
-class <i>copier</i>, that takes a single Boolean template parameter, and has a
-static template member function <font size="2" face="Courier New">do_copy</font>
-which performs the generic version of <font size="2">copy</font> (in other words
-the &quot;slow but safe version&quot;). Following that there is a specialisation
-for <i>copier&lt;true&gt;</i>: again this defines a static template member
-function <font size="2" face="Courier New">do_copy</font>, but this version uses
-memcpy to perform an &quot;optimised&quot; copy.</p>
-<p>In order to complete the implementation, what we need now is a version of
-copy, that calls <code>copier&lt;true&gt;::do_copy</code> if it is safe to use <font size="2" face="Courier New">memcpy</font>,
-and otherwise calls <code>copier&lt;false&gt;::do_copy</code> to do a
-&quot;generic&quot; copy. This is what the version in listing 1 does. To
-understand how the code works look at the code for <font size="2" face="Courier New">copy</font>
-and consider first the two typedefs <i>v1_t</i> and <i>v2_t</i>. These use <code>std::iterator_traits&lt;Iter1&gt;::value_type</code>
-to determine what type the two iterators point to, and then feed the result into
-another type-traits class <i>remove_cv</i> that removes the top-level
-const-volatile-qualifiers: this will allow copy to compare the two types without
-regard to const- or volatile-qualifiers. Next, <font size="2" face="Courier New">copy</font>
-declares an enumerated value <i>can_opt</i> that will become the template
-parameter to copier - declaring this here as a constant is really just a
-convenience - the value could be passed directly to class <font size="2" face="Courier New">copier</font>.
-The value of <i>can_opt</i> is computed by verifying that all of the following
-are true:</p>
-<ul>
-  <li>first that the two iterators point to the same type by using a type-traits
-    class <i>is_same</i>.</li>
-  <li>Then that both iterators are real pointers - using the class <i>is_pointer</i>
-    described above.</li>
-  <li>Finally that the pointed-to types have a trivial assignment operator using
-    <i>has_trivial_assign</i>.</li>
-</ul>
-<p>Finally we can use the value of <i>can_opt</i> as the template argument to
-copier - this version of copy will now adapt to whatever parameters are passed
-to it, if its possible to use <font size="2" face="Courier New">memcpy</font>,
-then it will do so, otherwise it will use a generic copy.</p>
-<h4>Was it worth it?</h4>
-<p>It has often been repeated in these columns that &quot;premature optimisation
-is the root of all evil&quot; [4]. So the question must be asked: was our
-optimisation premature? To put this in perspective the timings for our version
-of copy compared a conventional generic copy[5] are shown in table 1.</p>
-<p>Clearly the optimisation makes a difference in this case; but, to be fair,
-the timings are loaded to exclude cache miss effects - without this accurate
-comparison between algorithms becomes difficult. However, perhaps we can add a
-couple of caveats to the premature optimisation rule:</p>
-<ul>
-  <li>If you use the right algorithm for the job in the first place then
-    optimisation will not be required; in some cases, <font size="2" face="Courier New">memcpy</font>
-    is the right algorithm.</li>
-  <li>If a component is going to be reused in many places by many people then
-    optimisations may well be worthwhile where they would not be so for a single
-    case - in other words, the likelihood that the optimisation will be
-    absolutely necessary somewhere, sometime is that much higher. Just as
-    importantly the perceived value of the stock implementation will be higher:
-    there is no point standardising an algorithm if users reject it on the
-    grounds that there are better, more heavily optimised versions available.</li>
-</ul>
-<h4>Table 1: Time taken to copy 1000 elements using copy&lt;const T*, T*&gt;
-(times in micro-seconds)</h4>
-<table border="1" cellpadding="7" cellspacing="1" width="529">
-  <tr>
-    <td valign="top" width="33%">
-      <p align="center">Version</p>
-    </td>
-    <td valign="top" width="33%">
-      <p align="center">T</p>
-    </td>
-    <td valign="top" width="33%">
-      <p align="center">Time</p>
-    </td>
-  </tr>
-  <tr>
-    <td valign="top" width="33%">&quot;Optimised&quot; copy</td>
-    <td valign="top" width="33%">char</td>
-    <td valign="top" width="33%">0.99</td>
-  </tr>
-  <tr>
-    <td valign="top" width="33%">Conventional copy</td>
-    <td valign="top" width="33%">char</td>
-    <td valign="top" width="33%">8.07</td>
-  </tr>
-  <tr>
-    <td valign="top" width="33%">&quot;Optimised&quot; copy</td>
-    <td valign="top" width="33%">int</td>
-    <td valign="top" width="33%">2.52</td>
-  </tr>
-  <tr>
-    <td valign="top" width="33%">Conventional copy</td>
-    <td valign="top" width="33%">int</td>
-    <td valign="top" width="33%">8.02</td>
-  </tr>
-</table>
-<p>&nbsp;</p>
-<h4>Pair of References</h4>
-<p>The optimised copy example shows how type traits may be used to perform
-optimisation decisions at compile-time. Another important usage of type traits
-is to allow code to compile that otherwise would not do so unless excessive
-partial specialization is used. This is possible by delegating partial
-specialization to the type traits classes. Our example for this form of usage is
-a pair that can hold references [6].</p>
-<p>First, let us examine the definition of &quot;std::pair&quot;, omitting the
-comparision operators, default constructor, and template copy constructor for
-simplicity:</p>
-<pre>template &lt;typename T1, typename T2&gt; 
-struct pair 
-{
-  typedef T1 first_type;
-  typedef T2 second_type;
-
-  T1 first;
-  T2 second;
-
-  pair(const T1 &amp; nfirst, const T2 &amp; nsecond)
-  :first(nfirst), second(nsecond) { }
-};</pre>
-<p>Now, this &quot;pair&quot; cannot hold references as it currently stands,
-because the constructor would require taking a reference to a reference, which
-is currently illegal [7]. Let us consider what the constructor's parameters
-would have to be in order to allow &quot;pair&quot; to hold non-reference types,
-references, and constant references:</p>
-<table border="1" cellpadding="7" cellspacing="1" width="638">
-  <tr>
-    <td valign="top" width="50%">Type of &quot;T1&quot;</td>
-    <td valign="top" width="50%">Type of parameter to initializing constructor</td>
-  </tr>
-  <tr>
-    <td valign="top" width="50%">
-      <pre>T</pre>
-    </td>
-    <td valign="top" width="50%">
-      <pre>const T &amp;</pre>
-    </td>
-  </tr>
-  <tr>
-    <td valign="top" width="50%">
-      <pre>T &amp;</pre>
-    </td>
-    <td valign="top" width="50%">
-      <pre>T &amp;</pre>
-    </td>
-  </tr>
-  <tr>
-    <td valign="top" width="50%">
-      <pre>const T &amp;</pre>
-    </td>
-    <td valign="top" width="50%">
-      <pre>const T &amp;</pre>
-    </td>
-  </tr>
-</table>
-<p>A little familiarity with the type traits classes allows us to construct a
-single mapping that allows us to determine the type of parameter from the type
-of the contained class. The type traits classes provide a transformation &quot;add_reference&quot;,
-which adds a reference to its type, unless it is already a reference.</p>
-<table border="1" cellpadding="7" cellspacing="1" width="580">
-  <tr>
-    <td valign="top" width="21%">Type of &quot;T1&quot;</td>
-    <td valign="top" width="27%">Type of &quot;const T1&quot;</td>
-    <td valign="top" width="53%">Type of &quot;add_reference&lt;const
-      T1&gt;::type&quot;</td>
-  </tr>
-  <tr>
-    <td valign="top" width="21%">
-      <pre>T</pre>
-    </td>
-    <td valign="top" width="27%">
-      <pre>const T</pre>
-    </td>
-    <td valign="top" width="53%">
-      <pre>const T &amp;</pre>
-    </td>
-  </tr>
-  <tr>
-    <td valign="top" width="21%">
-      <pre>T &amp;</pre>
-    </td>
-    <td valign="top" width="27%">
-      <pre>T &amp; [8]</pre>
-    </td>
-    <td valign="top" width="53%">
-      <pre>T &amp;</pre>
-    </td>
-  </tr>
-  <tr>
-    <td valign="top" width="21%">
-      <pre>const T &amp;</pre>
-    </td>
-    <td valign="top" width="27%">
-      <pre>const T &amp;</pre>
-    </td>
-    <td valign="top" width="53%">
-      <pre>const T &amp;</pre>
-    </td>
-  </tr>
-</table>
-<p>This allows us to build a primary template definition for &quot;pair&quot;
-that can contain non-reference types, reference types, and constant reference
-types:</p>
-<pre>template &lt;typename T1, typename T2&gt; 
-struct pair 
-{
-  typedef T1 first_type;
-  typedef T2 second_type;
-
-  T1 first;
-  T2 second;
-
-  pair(boost::add_reference&lt;const T1&gt;::type nfirst,
-       boost::add_reference&lt;const T2&gt;::type nsecond)
-  :first(nfirst), second(nsecond) { }
-};</pre>
-<p>Add back in the standard comparision operators, default constructor, and
-template copy constructor (which are all the same), and you have a std::pair
-that can hold reference types!</p>
-<p>This same extension <i>could</i> have been done using partial template
-specialization of &quot;pair&quot;, but to specialize &quot;pair&quot; in this
-way would require three partial specializations, plus the primary template. Type
-traits allows us to define a single primary template that adjusts itself
-auto-magically to any of these partial specializations, instead of a brute-force
-partial specialization approach. Using type traits in this fashion allows
-programmers to delegate partial specialization to the type traits classes,
-resulting in code that is easier to maintain and easier to understand.</p>
-<h4>Conclusion</h4>
-<p>We hope that in this article we have been able to give you some idea of what
-type-traits are all about. A more complete listing of the available classes are
-in the boost documentation, along with further examples using type traits.
-Templates have enabled C++ uses to take the advantage of the code reuse that
-generic programming brings; hopefully this article has shown that generic
-programming does not have to sink to the lowest common denominator, and that
-templates can be optimal as well as generic.</p>
-<h4>Acknowledgements</h4>
-<p>The authors would like to thank Beman Dawes and Howard Hinnant for their
-helpful comments when preparing this article.</p>
-<h4>References</h4>
-<ol>
-  <li>Nathan C. Myers, C++ Report, June 1995.</li>
-  <li>The type traits library is based upon contributions by Steve Cleary, Beman
-    Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org.</li>
-  <li>A scalar type is an arithmetic type (i.e. a built-in integer or floating
-    point type), an enumeration type, a pointer, a pointer to member, or a
-    const- or volatile-qualified version of one of these types.</li>
-  <li>This quote is from Donald Knuth, ACM Computing Surveys, December 1974, pg
-    268.</li>
-  <li>The test code is available as part of the boost utility library (see
-    algo_opt_examples.cpp), the code was compiled with gcc 2.95 with all
-    optimisations turned on, tests were conducted on a 400MHz Pentium II machine
-    running Microsoft Windows 98.</li>
-  <li>John Maddock and Howard Hinnant have submitted a &quot;compressed_pair&quot;
-    library to Boost, which uses a technique similar to the one described here
-    to hold references. Their pair also uses type traits to determine if any of
-    the types are empty, and will derive instead of contain to conserve space --
-    hence the name &quot;compressed&quot;.</li>
-  <li>This is actually an issue with the C++ Core Language Working Group (issue
-    #106), submitted by Bjarne Stroustrup. The tentative resolution is to allow
-    a &quot;reference to a reference to T&quot; to mean the same thing as a
-    &quot;reference to T&quot;, but only in template instantiation, in a method
-    similar to multiple cv-qualifiers.</li>
-  <li>For those of you who are wondering why this shouldn't be const-qualified,
-    remember that references are always implicitly constant (for example, you
-    can't re-assign a reference). Remember also that &quot;const T &amp;&quot;
-    is something completely different. For this reason, cv-qualifiers on
-    template type arguments that are references are ignored.</li>
-</ol>
-<h2>Listing 1</h2>
-<pre>namespace detail{
-
-template &lt;bool b&gt;
-struct copier
-{
-   template&lt;typename I1, typename I2&gt;
-   static I2 do_copy(I1 first, 
-                     I1 last, I2 out);
-};
-
-template &lt;bool b&gt;
-template&lt;typename I1, typename I2&gt;
-I2 copier&lt;b&gt;::do_copy(I1 first, 
-                      I1 last, 
-                      I2 out)
-{
-   while(first != last)
-   {
-      *out = *first;
-      ++out;
-      ++first;
-   }
-   return out;
-}
-
-template &lt;&gt;
-struct copier&lt;true&gt;
-{
-   template&lt;typename I1, typename I2&gt;
-   static I2* do_copy(I1* first, I1* last, I2* out)
-   {
-      memcpy(out, first, (last-first)*sizeof(I2));
-      return out+(last-first);
-   }
-};
-
-}
-
-template&lt;typename I1, typename I2&gt;
-inline I2 copy(I1 first, I1 last, I2 out)
-{
-   typedef typename 
-    boost::remove_cv&lt;
-     typename std::iterator_traits&lt;I1&gt;
-      ::value_type&gt;::type v1_t;
-
-   typedef typename 
-    boost::remove_cv&lt;
-     typename std::iterator_traits&lt;I2&gt;
-      ::value_type&gt;::type v2_t;
-
-   enum{ can_opt = 
-      boost::is_same&lt;v1_t, v2_t&gt;::value
-      &amp;&amp; boost::is_pointer&lt;I1&gt;::value
-      &amp;&amp; boost::is_pointer&lt;I2&gt;::value
-      &amp;&amp; boost::
-      has_trivial_assign&lt;v1_t&gt;::value 
-   };
-
-   return detail::copier&lt;can_opt&gt;::
-      do_copy(first, last, out);
-}</pre>
-<hr>
-<p><EFBFBD> Copyright John Maddock and Steve Cleary, 2000</p>
-
-</body>
-
-</html>
--- a/call_traits.htm
+++ b/call_traits.htm
@@ -27,10 +27,16 @@ never occur, and that parameters are passed in the most efficient
 manner possible (see <a href="#examples">examples</a>). In each
 case if your existing practice is to use the type defined on the
 left, then replace it with the call_traits defined type on the
-right. Note that for compilers that do not support partial
-specialization, no benefit will occur from using call_traits: the
-call_traits defined types will always be the same as the existing
-practice in this case.</p>
+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>
@@ -73,7 +79,8 @@ practice in this case.</p>
        </td>
    </tr>
    <tr>
-        <td valign="top" width="17%"><p align="center">const T&amp;<br>
+        <td valign="top" width="17%"><p align="center">const
+        T&amp;<br>
        (return value)</p>
        </td>
        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::const_reference</code></p>
@@ -85,7 +92,8 @@ practice in this case.</p>
        </td>
    </tr>
    <tr>
-        <td valign="top" width="17%"><p align="center">const T&amp;<br>
+        <td valign="top" width="17%"><p align="center">const
+        T&amp;<br>
        (function parameter)</p>
        </td>
        <td valign="top" width="35%"><p align="center"><code>call_traits&lt;T&gt;::param_type</code></p>
@@ -326,8 +334,8 @@ possible:</p>
 <p>The following table shows the effect that call_traits has on
 various types, the table assumes that the compiler supports
 partial specialization: if it doesn't then all types behave in
-the same way as the entry for &quot;myclass&quot;, and call_traits
-can not be used with reference or array types.</p>
+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>
@@ -382,7 +390,8 @@ can not be used with reference or array types.</p>
        </td>
        <td valign="top" width="17%"><p align="center">int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
+        int&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">int const</p>
        </td>
@@ -414,7 +423,8 @@ can not be used with reference or array types.</p>
        </td>
        <td valign="top" width="17%"><p align="center">int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
+        int&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">int&amp;</p>
        </td>
@@ -426,13 +436,17 @@ can not be used with reference or array types.</p>
        <td valign="top" width="17%" bgcolor="#C0C0C0"><p
        align="center">const int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
+        int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
+        int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
+        int&amp;</p>
        </td>
-        <td valign="top" width="17%"><p align="center">const int&amp;</p>
+        <td valign="top" width="17%"><p align="center">const
+        int&amp;</p>
        </td>
        <td valign="top" width="17%"><p align="center">All
        constant-references.</p>
@@ -480,8 +494,8 @@ can not be used with reference or array types.</p>

 <p>The following class is a trivial class that stores some type T
 by value (see the <a href="call_traits_test.cpp">call_traits_test.cpp</a>
-file), the aim is to illustrate how each of the available call_traits
-typedefs may be used:</p>
+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
@@ -517,14 +531,14 @@ problem):</h4>

 <pre>template &lt;class Operation&gt; 
 class binder1st : 
-   public unary_function&lt;Operation::second_argument_type, Operation::result_type&gt; 
+   public unary_function&lt;typename Operation::second_argument_type, typename Operation::result_type&gt; 
 { 
 protected: 
   Operation op; 
-   Operation::first_argument_type value; 
+   typename Operation::first_argument_type value; 
 public: 
-   binder1st(const Operation&amp; x, const Operation::first_argument_type&amp; y); 
-   Operation::result_type operator()(const Operation::second_argument_type&amp; x) const; 
+   binder1st(const Operation&amp; x, const typename Operation::first_argument_type&amp; y); 
+   typename Operation::result_type operator()(const typename Operation::second_argument_type&amp; x) const; 
 }; </pre>

 <p>Now consider what happens in the relatively common case that
@@ -535,7 +549,7 @@ reference to a reference as an argument, and that is not
 currently legal. The solution here is to modify <code>operator()</code>
 to use call_traits:</p>

-<pre>Operation::result_type operator()(call_traits&lt;Operation::second_argument_type&gt;::param_type x) const;</pre>
+<pre>typename Operation::result_type operator()(typename call_traits&lt;typename Operation::second_argument_type&gt;::param_type x) const;</pre>

 <p>Now in the case that <code>Operation::second_argument_type</code>
 is a reference type, the argument is passed as a reference, and
@@ -569,7 +583,9 @@ std::pair&lt;
 degraded to pointers if the deduced types are arrays, similar
 situations occur in the standard binders and adapters: in
 principle in any function that &quot;wraps&quot; a temporary
-whose type is deduced.</p>
+whose type is deduced. Note that the function arguments to
+make_pair are not expressed in terms of call_traits: doing so
+would prevent template argument deduction from functioning.</p>

 <h4><a name="ex4"></a>Example 4 (optimising fill):</h4>

@@ -632,6 +648,14 @@ Exactly how much mileage you will get from this depends upon your
 compiler - we could really use some accurate benchmarking
 software as part of boost for cases like this.</p>

+<p>Note that the function arguments to fill are not expressed in
+terms of call_traits: doing so would prevent template argument
+deduction from functioning. Instead fill acts as a &quot;thin
+wrapper&quot; that is there to perform template argument
+deduction, the compiler will optimise away the call to fill all
+together, replacing it with the call to filler&lt;&gt;::do_fill,
+which does use call_traits.</p>
+
 <h3>Rationale</h3>

 <p>The following notes are intended to briefly describe the
@@ -650,10 +674,10 @@ be any worse than existing practice.</p>
 <p>Pointers follow the same rational as small built-in types.</p>

 <p>For reference types the rational follows <a href="#refs">Example
-2</a> - references to references are not allowed, so the call_traits
-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,
+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
@@ -671,11 +695,11 @@ struct A
   void foo(T t);
 };</pre>

-<p><font face="Times New Roman">In this case if we instantiate A&lt;int[2]&gt;
-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>
+<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)
@@ -690,13 +714,13 @@ declared type:</p>
 <pre>template &lt;class T&gt;
 struct A
 {
-   void foo(call_traits&lt;T&gt;::value_type t);
+   void foo(typename call_traits&lt;T&gt;::value_type t);
 };

 template &lt;class T&gt;
-void A&lt;T&gt;::foo(call_traits&lt;T&gt;::value_type t)
+void A&lt;T&gt;::foo(typename call_traits&lt;T&gt;::value_type t)
 {
-   call_traits&lt;T&gt;::value_type dup(t); // OK even if T is an array type.
+   typename call_traits&lt;T&gt;::value_type dup(t); // OK even if T is an array type.
 }</pre>

 <p>For value_type (return by value), again only a pointer may be
@@ -713,7 +737,7 @@ specialisation).</p>

 <hr>

-<p>Revised 18 June 2000</p>
+<p>Revised 01 September 2000</p>

 <p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
 sell and distribute this document is granted provided this
--- a/call_traits_test.cpp
+++ b/call_traits_test.cpp
@@ -6,6 +6,8 @@
 //  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>
@@ -14,7 +16,7 @@
 #include <typeinfo>
 #include <boost/call_traits.hpp>

-#include "type_traits_test.hpp"
+#include <boost/type_traits/type_traits_test.hpp>
 //
 // 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:
@@ -96,18 +98,18 @@ std::pair<
 using namespace std;

 //
-// struct checker:
+// struct call_traits_checker:
 // verifies behaviour of contained example:
 //
 template <class T>
-struct checker
+struct call_traits_checker
 {
   typedef typename boost::call_traits<T>::param_type param_type;
   void operator()(param_type);
 };

 template <class T>
-void checker<T>::operator()(param_type p)
+void call_traits_checker<T>::operator()(param_type p)
 {
   T t(p);
   contained<T> c(t);
@@ -115,18 +117,19 @@ void checker<T>::operator()(param_type p)
   assert(t == c.value());
   assert(t == c.get());
   assert(t == c.const_get());
-
-   cout << "typeof contained<" << typeid(T).name() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
+#ifndef __ICL
+   //cout << "typeof contained<" << typeid(T).name() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::value() is:      " << typeid(&contained<T>::value).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::get() is:        " << typeid(&contained<T>::get).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::const_get() is:  " << typeid(&contained<T>::const_get).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::call() is:       " << typeid(&contained<T>::call).name() << endl;
   cout << endl;
+#endif
 }

 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T, std::size_t N>
-struct checker<T[N]>
+struct call_traits_checker<T[N]>
 {
   typedef typename boost::call_traits<T[N]>::param_type param_type;
   void operator()(param_type t)
@@ -174,33 +177,34 @@ void check_make_pair(T c, U u, V v)
 }


-struct UDT
+struct comparible_UDT
 {
   int i_;
-   UDT() : i_(2){}
-   bool operator == (const UDT& v){ return v.i_ == i_; }
+   comparible_UDT() : i_(2){}
+   bool operator == (const comparible_UDT& v){ return v.i_ == i_; }
 };

-int main()
+int main(int argc, char *argv[ ])
 {
-   checker<UDT> c1;
-   UDT u;
+   call_traits_checker<comparible_UDT> c1;
+   comparible_UDT u;
   c1(u);
-   checker<int> c2;
+   call_traits_checker<int> c2;
   int i = 2;
   c2(i);
   int* pi = &i;
-   checker<int*> c3;
+#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
+   call_traits_checker<int*> c3;
   c3(pi);
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   checker<int&> c4;
+   call_traits_checker<int&> c4;
   c4(i);
-   checker<const int&> c5;
+   call_traits_checker<const int&> c5;
   c5(i);
-
+#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   int a[2] = {1,2};
-   checker<int[2]> c6;
+   call_traits_checker<int[2]> c6;
   c6(a);
+#endif
 #endif

   check_wrap(wrap(2), 2);
@@ -217,10 +221,10 @@ int main()
   typedef int& r_type;
   typedef const r_type cr_type;

-   type_test(UDT, boost::call_traits<UDT>::value_type)
-   type_test(UDT&, boost::call_traits<UDT>::reference)
-   type_test(const UDT&, boost::call_traits<UDT>::const_reference)
-   type_test(const UDT&, boost::call_traits<UDT>::param_type)
+   type_test(comparible_UDT, boost::call_traits<comparible_UDT>::value_type)
+   type_test(comparible_UDT&, boost::call_traits<comparible_UDT>::reference)
+   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference)
+   type_test(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type)
   type_test(int, boost::call_traits<int>::value_type)
   type_test(int&, boost::call_traits<int>::reference)
   type_test(const int&, boost::call_traits<int>::const_reference)
@@ -229,7 +233,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)
@@ -248,6 +252,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)
@@ -256,15 +261,18 @@ 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;
   test_count += 20;
 #endif

-   std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
-   std::cin.get();
-   return failures;
+   return check_result(argc, argv);
 }

 //
@@ -318,7 +326,7 @@ struct call_traits_test<T, true>
 };

 template <typename T>
-void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_type val)
+void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>::param_type val)
 {
   //
   // this is to check that the call_traits assertions are valid:
@@ -347,9 +355,23 @@ void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_ty
 template struct call_traits_test<int>;
 template struct call_traits_test<const int>;
 template struct call_traits_test<int*>;
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !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
+
+#ifdef BOOST_MSVC
+unsigned int expected_failures = 10;
+#elif defined(__BORLANDC__)
+unsigned int expected_failures = 2;
+#elif defined(__GNUC__)
+unsigned int expected_failures = 4;
+#else
+unsigned int expected_failures = 0;
+#endif
+
+

--- a/cast.htm
+++ b/cast.htm
@@ -1,148 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<title>Header boost/cast.hpp Documentation</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
-<a href="../../boost/cast.hpp">boost/cast.hpp</a></h1>
-<h2><a name="Cast Functions">Cast Functions</a></h2>
-<p>The <code>header <a href="../../boost/cast.hpp">boost/cast.hpp</a></code>
-provides <a href="#Polymorphic_cast"><b>polymorphic_cast</b></a>, <a href="#Polymorphic_cast"><b>polymorphic_downcast</b></a>,
-and <a href="#numeric_cast"><b>numeric_cast</b></a> template functions designed
-to complement the C++ Standard's built-in casts.</p>
-<p>The program&nbsp;<a href="cast_test.cpp">cast_test.cpp</a> can be used to
-verify these function templates work as expected.</p>
-<p><b>polymorphic_cast</b> was suggested by Bjarne Stroustrup in &quot;The C++
-Programming Language&quot;.<br>
-<b>polymorphic_downcast</b> was contributed by <a href="../../people/dave_abrahams.htm">Dave
-Abrahams</a>.<b><br>
-numeric_cast</b> was contributed by <a href="../../people/kevlin_henney.htm">Kevlin
-Henney</a>.</p>
-<h3>Namespace synopsis</h3>
-<blockquote>
-  <pre>namespace boost {
-    namespace cast {
-        // all synopsis below included here
-    }
-  using ::boost::cast::polymorphic_cast;
-  using ::boost::cast::polymorphic_downcast;
-  using ::boost::cast::bad_numeric_cast;
-  using ::boost::cast::numeric_cast;
-}</pre>
-</blockquote>
-<h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
-<p>Pointers to polymorphic objects (objects of classes which define at least one
-virtual function) are sometimes downcast or crosscast.&nbsp; Downcasting means
-casting from a base class to a derived class.&nbsp; Crosscasting means casting
-across an inheritance hierarchy diagram, such as from one base to the other in a
-<b>Y</b> diagram hierarchy.</p>
-<p>Such casts can be done with old-style casts, but this approach is never to be
-recommended.&nbsp; Old-style casts are sorely lacking in type safety, suffer
-poor readability, and are difficult to locate with search tools.</p>
-<p>The C++ built-in <b>static_cast</b> can be used for efficiently downcasting
-pointers to polymorphic objects, but provides no error detection for the case
-where the pointer being cast actually points to the wrong derived class. The <b>polymorphic_downcast</b>
-template retains the efficiency of <b>static_cast</b> for non-debug
-compilations, but for debug compilations adds safety via an assert() that a <b>dynamic_cast</b>
-succeeds.&nbsp;<b>&nbsp;</b></p>
-<p>The C++ built-in <b>dynamic_cast</b> can be used for downcasts and crosscasts
-of pointers to polymorphic objects, but error notification in the form of a
-returned value of 0 is inconvenient to test, or worse yet, easy to forget to
-test.&nbsp; The <b>polymorphic_cast</b> template performs a <b>dynamic_cast</b>,
-and throws an exception if the <b>dynamic_cast</b> returns 0.</p>
-<p>A <b>polymorphic_downcast</b> is preferred when debug-mode tests will cover
-100% of the object types possibly cast and when non-debug-mode efficiency is an
-issue. If these two conditions are not present, <b>polymorphic_cast</b> is
-preferred.&nbsp; It must also be used for crosscasts.&nbsp; It does an assert(
-dynamic_cast&lt;Derived&gt;(x) == x ) where x is the base pointer, ensuring that
-not only is a non-zero pointer returned, but also that it correct in the
-presence of multiple inheritance. .<b> Warning:</b>: Because <b>polymorphic_downcast</b>
-uses assert(), it violates the One Definition Rule if NDEBUG is inconsistently
-defined across translation units.</p>
-<p>The C++ built-in <b>dynamic_cast</b> must be used to cast references rather
-than pointers.&nbsp; It is also the only cast that can be used to check whether
-a given interface is supported; in that case a return of 0 isn't an error
-condition.</p>
-<h3>polymorphic_cast and polymorphic_downcast synopsis</h3>
-<blockquote>
-  <pre>template &lt;class Derived, class Base&gt;
-inline Derived polymorphic_cast(Base* x);
-// Throws: std::bad_cast if ( dynamic_cast&lt;Derived&gt;(x) == 0 )
-// Returns: dynamic_cast&lt;Derived&gt;(x)
-
-template &lt;class Derived, class Base&gt;
-inline Derived polymorphic_downcast(Base* x);
-// Effects: assert( dynamic_cast&lt;Derived&gt;(x) == x );
-// Returns: static_cast&lt;Derived&gt;(x)</pre>
-</blockquote>
-<h3>polymorphic_downcast example</h3>
-<blockquote>
-  <pre>#include &lt;boost/cast.hpp&gt;
-...
-class Fruit { public: virtual ~Fruit(){}; ... };
-class Banana : public Fruit { ... };
-...
-void f( Fruit * fruit ) {
-// ... logic which leads us to believe it is a Banana
-  Banana * banana = boost::polymorphic_downcast&lt;Banana*&gt;(fruit);
-  ...</pre>
-</blockquote>
-<h3><a name="numeric_cast">numeric_cast</a></h3>
-<p>A <b>static_cast</b>, <b>implicit_cast</b> or implicit conversion will not
-detect failure to preserve range for numeric casts. The <b>numeric_cast</b>
-template function are similar to <b>static_cast</b> and certain (dubious)
-implicit conversions in this respect, except that they detect loss of numeric
-range. An exception is thrown when a runtime value preservation check fails.</p>
-<p>The requirements on the argument and result types are:</p>
-<blockquote>
-  <ul>
-    <li>Both argument and result types are CopyConstructible [20.1.3].</li>
-    <li>Both argument and result types are Numeric, defined by <code>std::numeric_limits&lt;&gt;::is_specialized</code>
-      being true.</li>
-    <li>The argument can be converted to the result type using <b>static_cast</b>.</li>
-  </ul>
-</blockquote>
-<h3>numeric_cast synopsis</h3>
-<blockquote>
-  <pre>class bad_numeric_cast : public std::bad_cast {...};
-
-template&lt;typename Target, typename Source&gt;
-  inline Target numeric_cast(Source arg);
-    // Throws:  bad_numeric_cast unless, in converting arg from Source to Target,
-    //          there is no loss of negative range, and no underflow, and no
-    //          overflow, as determined by std::numeric_limits
-    // Returns: static_cast&lt;Target&gt;(arg)</pre>
-</blockquote>
-<h3>numeric_cast example</h3>
-<blockquote>
-  <pre>#include &lt;boost/cast.hpp&gt;
-using namespace boost::cast;
-
-void ariane(double vx)
-{
-    ...
-    unsigned short dx = numeric_cast&lt;unsigned short&gt;(vx);
-    ...
-}</pre>
-</blockquote>
-<h3>numeric_cast rationale</h3>
-<p>The form of the throws condition is specified so that != is not a required
-operation.</p>
-<hr>
-<p>Revised&nbsp; <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
-->28 June, 2000<!--webbot bot="Timestamp" endspan i-checksum="19846"
--></p>
-<p><EFBFBD> Copyright boost.org 1999. Permission to copy, use, modify, sell and
-distribute this document is granted provided this copyright notice appears in
-all copies. This document is provided &quot;as is&quot; without express or
-implied warranty, and with no claim as to its suitability for any purpose.</p>
-
-</body>
-
-</html>
--- a/cast_test.cpp
+++ b/cast_test.cpp
@@ -1,149 +0,0 @@
-//  boost utility cast test program  -----------------------------------------//
-
-//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
-//  and distribute this software is granted provided this copyright
-//  notice appears in all copies. This software is provided "as is" without
-//  express or implied warranty, and with no claim as to its suitability for
-//  any purpose.
-
-//  See http://www.boost.org for most recent version including documentation.
-
-//  Revision History
-//   28 Jun 00  implicit_cast removed (Beman Dawes)
-//   30 Aug 99  value_cast replaced by numeric_cast
-//    3 Aug 99  Initial Version
-
-#include <iostream>
-#include <climits>
-#include <limits>
-#include <boost/cast.hpp>
-
-#  if SCHAR_MAX == LONG_MAX
-#      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
-#  endif 
-
-using namespace boost;
-using std::cout;
-
-namespace
-{
-    struct Base
-    { 
-        virtual char kind() { return 'B'; }
-    };
-    
-    struct Base2
-    { 
-        virtual char kind2() { return '2'; }
-    };
-    
-    struct Derived : public Base, Base2
-    {
-        virtual char kind() { return 'D'; }
-    }; 
-}   
-
-
-int main( int argc, char * argv[] )
-{
-    cout << "Usage: test_casts [n], where n omitted or is:\n"
-            "  1 = execute #1 assert failure (#ifndef NDEBUG)\n"
-            "  2 = execute #2 assert failure (#ifndef NDEBUG)\n"
-            "Example: test_casts 2\n\n";
-
-#   ifdef NDEBUG
-        cout << "NDEBUG is defined\n";
-#   else
-        cout << "NDEBUG is not defined\n";
-#   endif
-
-    cout << "\nBeginning tests...\n";        
-
-//  test polymorphic_cast  ---------------------------------------------------//
-    
-    //  tests which should succeed
-    Base *    base = new Derived;
-    Base2 *   base2 = 0;
-    Derived * derived = 0;
-    derived = polymorphic_downcast<Derived*>( base );  // downcast
-    assert( derived->kind() == 'D' );
-
-    derived = 0;
-    derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
-    assert( derived->kind() == 'D' );
-
-    base2 = polymorphic_cast<Base2*>( base ); // crosscast
-    assert( base2->kind2() == '2' );
-
-     //  tests which should result in errors being detected
-    int err_count = 0;
-    base = new Base;
-
-    if ( argc > 1 && *argv[1] == '1' )
-        { derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
-
-    bool caught_exception = false;
-    try { derived = polymorphic_cast<Derived*>( base ); }
-    catch (std::bad_cast)
-        { cout<<"caught bad_cast\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-    //  the following is just so generated code can be inspected
-    if ( derived->kind() == 'B' ) ++err_count;
-
-//  test implicit_cast and numeric_cast  -------------------------------------//
-    
-    //  tests which should succeed
-    long small_value = 1;
-    long small_negative_value = -1;
-    long large_value = std::numeric_limits<long>::max();
-    long large_negative_value = std::numeric_limits<long>::min();
-    signed char c = 0;
-
-    c = large_value;  // see if compiler generates warning
-
-    c = numeric_cast<signed char>( small_value );
-    assert( c == 1 );
-    c = 0;
-    c = numeric_cast<signed char>( small_value );
-    assert( c == 1 );
-    c = 0;
-    c = numeric_cast<signed char>( small_negative_value );
-    assert( c == -1 );
-
-    //  tests which should result in errors being detected
-
-    caught_exception = false;
-    try { c = numeric_cast<signed char>( large_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    caught_exception = false;
-    try { c = numeric_cast<signed char>( large_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    unsigned long ul;
-    caught_exception = false;
-    try { ul = numeric_cast<unsigned long>( large_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    caught_exception = false;
-    try { ul = numeric_cast<unsigned long>( small_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    caught_exception = false;
-    try { numeric_cast<int>( std::numeric_limits<double>::max() ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
-
-    cout << err_count << " errors detected\nTest "
-         << (err_count==0 ? "passed\n" : "failed\n");
-    return err_count;
-}   // main
--- a/compressed_pair_test.cpp
+++ b/compressed_pair_test.cpp
@@ -6,21 +6,18 @@
 //  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"
+#include <boost/type_traits/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>
@@ -39,8 +36,25 @@ template <> struct is_POD<empty_POD_UDT>
 #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; }
+};

-int main()
+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(int argc, char *argv[ ])
 {
   compressed_pair<int, double> cp1(1, 1.3);
   assert(cp1.first() == 1);
@@ -53,15 +67,25 @@ int main()
   assert(cp1b.second() == 1.3);
   assert(cp1.first() == 2);
   assert(cp1.second() == 2.3);
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   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);
-#endif
   compressed_pair<int, empty_UDT> cp3(1);
   assert(cp3.first() ==1);
   compressed_pair<empty_UDT, empty_UDT> cp4;
   compressed_pair<empty_UDT, empty_POD_UDT> cp5;
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   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);
@@ -72,15 +96,13 @@ int main()
   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> >)))
+   soft_value_test(true, (sizeof(compressed_pair<empty_UDT, int>) < sizeof(std::pair<empty_UDT, int>)))
+   soft_value_test(true, (sizeof(compressed_pair<int, empty_UDT>) < sizeof(std::pair<int, empty_UDT>)))
+   soft_value_test(true, (sizeof(compressed_pair<empty_UDT, empty_UDT>) < sizeof(std::pair<empty_UDT, empty_UDT>)))
+   soft_value_test(true, (sizeof(compressed_pair<empty_UDT, empty_POD_UDT>) < sizeof(std::pair<empty_UDT, empty_POD_UDT>)))
+   soft_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;
+   return check_result(argc, argv);
 }

 //
@@ -102,25 +124,30 @@ 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 __MWERKS__
 #ifndef __BORLANDC__
 template call_traits<int[2]>::reference compressed_pair<double, int[2]>::second();
 #endif
 template call_traits<double>::reference compressed_pair<double, int[2]>::first();
-template compressed_pair<double, int[2]>::compressed_pair(const double&);
+#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

+unsigned int expected_failures = 0;



--- a/counting_iterator.htm
+++ b/counting_iterator.htm
@@ -0,0 +1,325 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<title>Counting Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+align="center" width="277" height="86">
+
+<h1>Counting Iterator Adaptor</h1>
+
+Defined in header
+<a href="../../boost/counting_iterator.hpp">boost/counting_iterator.hpp</a>
+
+<p>
+How would you fill up a vector with the numbers zero
+through one hundred using <a
+href="http://www.sgi.com/tech/stl/copy.html"><tt>std::copy()</tt></a>? The
+only iterator operation missing from builtin integer types is an
+<tt>operator*()</tt> that returns the current
+value of the integer.  The counting iterator adaptor adds this crucial piece of
+functionality to whatever type it wraps. One can use the
+counting iterator adaptor not only with integer types, but with any
+type that is <tt>Incrementable</tt> (see type requirements <a href="#requirements">below</a>).  The
+following <b>pseudo-code</b> shows the general idea of how the
+counting iterator is implemented.
+</p>
+
+<pre>
+  // inside a hypothetical counting_iterator class...
+  typedef Incrementable value_type;
+  value_type counting_iterator::operator*() const {
+    return this->base; // no dereference!
+  }
+</pre>
+
+All of the other operators of the counting iterator behave in the same
+fashion as the <tt>Incrementable</tt> base type.
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;class Incrementable&gt;
+  struct <a href="#counting_iterator_traits">counting_iterator_traits</a>;
+
+  template &lt;class Incrementable&gt;
+  struct <a href="#counting_iterator_generator">counting_iterator_generator</a>;
+
+  template &lt;class Incrementable&gt;
+  typename counting_iterator_generator&lt;Incrementable&gt;::type
+  <a href="#make_counting_iterator">make_counting_iterator</a>(Incrementable x);
+}
+</pre>
+
+<hr>
+
+<h2><a name="counting_iterator_generator">The Counting Iterator Type
+Generator</a></h2>
+
+The class template <tt>counting_iterator_generator&lt;Incrementable&gt;</tt> is a <a href="../../more/generic_programming.html#type_generator">type generator</a> for counting iterators.
+
+<pre>
+template &lt;class Incrementable&gt;
+class counting_iterator_generator
+{
+public:
+    typedef <a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt; type;
+};
+</pre>
+
+<h3>Example</h3>
+
+In this example we use the counting iterator generator to create a
+counting iterator, and count from zero to four.
+
+<pre>
+#include &lt;boost/config.hpp&gt;
+#include &lt;iostream&gt;
+#include &lt;boost/counting_iterator.hpp&gt;
+
+int main(int, char*[])
+{
+  // Example of using counting_iterator_generator
+  std::cout &lt;&lt; "counting from 0 to 4:" &lt;&lt; std::endl;
+  boost::counting_iterator_generator&lt;int&gt;::type first(0), last(4);
+  std::copy(first, last, std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+
+  // to be continued...
+</pre>
+The output from this part is:
+<pre>
+counting from 0 to 4:
+0 1 2 3 
+</pre>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><tt>Incrementable</tt></TD>
+<TD>The type being wrapped by the adaptor.</TD>
+</TR>
+
+</Table>
+
+<h3>Model of</h3>
+
+If the <tt>Incrementable</tt> type has all of the functionality of a
+<a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> except the <tt>operator*()</tt>, then the counting
+iterator will be a model of <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a>. If the <tt>Incrementable</tt> type has less
+functionality, then the counting iterator will have correspondingly
+less functionality.
+
+<h3><a name="requirements">Type Requirements</a></h3>
+
+The <tt>Incrementable</tt> type must be <a
+href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
+Constructible</a>, <a href="./CopyConstructible.html">Copy
+Constructible</a>, and <a href="./Assignable.html">Assignable</a>.
+Also, the <tt>Incrementable</tt> type must provide access to an
+associated <tt>difference_type</tt> and <tt>iterator_category</tt>
+through the <a
+href="#counting_iterator_traits"><tt>counting_iterator_traits</tt></a>
+class.
+
+<p>
+Furthermore, if you wish to create a counting iterator that is a <a
+href="http://www.sgi.com/tech/stl/ForwardIterator.html"> Forward
+Iterator</a>, then the following expressions must be valid:
+<pre>
+Incrementable i, j;
++i         // pre-increment
+i == j      // operator equal
+</pre>
+If you wish to create a counting iterator that is a <a
+href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">
+Bidirectional Iterator</a>, then pre-decrement is also required:
+<pre>
+--i
+</pre>
+If you wish to create a counting iterator that is a <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html"> Random
+Access Iterator</a>, then these additional expressions are also required:
+<pre>
+<a href="#counting_iterator_traits">counting_iterator_traits</a>&lt;Incrementable&gt;::difference_type n;
+i += n
+n = i - j
+i < j
+</pre>
+
+
+
+<h3>Members</h3>
+
+The counting iterator type implements the member functions and
+operators required of the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> concept. In addition it has the following
+constructor:
+
+<pre>
+counting_iterator_generator::type(const Incrementable&amp; i)
+</pre>
+
+<p>
+<hr>
+<p>
+
+
+<h2><a name="make_counting_iterator">The Counting Iterator Object Generator</a></h2>
+
+<pre>
+template &lt;class Incrementable&gt;
+typename counting_iterator_generator&lt;Incrementable&gt;::type
+make_counting_iterator(Incrementable base);
+</pre>
+
+An <a href="../../more/generic_programming.html#object_generator">object
+generator</a> function that provides a convenient way to create counting
+iterators.<p>
+
+
+
+<h3>Example</h3>
+
+In this example we count from negative five to positive five, this
+time using the <tt>make_counting_iterator()</tt> function to save some
+typing.
+
+<pre>
+  // continuing from previous example...
+
+  std::cout &lt;&lt; "counting from -5 to 4:" &lt;&lt; std::endl;
+  std::copy(boost::make_counting_iterator(-5),
+	    boost::make_counting_iterator(5),
+	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+
+  // to be continued...
+</pre>
+The output from this part is:
+<pre>
+counting from -5 to 4:
+-5 -4 -3 -2 -1 0 1 2 3 4 
+</pre>
+
+In the next example we create an array of numbers, and then create a
+second array of pointers, where each pointer is the address of a
+number in the first array. The counting iterator makes it easy to do
+this since dereferencing a counting iterator that is wrapping an
+iterator over the array of numbers just returns a pointer to the
+current location in the array. We then use the <a
+href="./indirect_iterator.htm">indirect iterator adaptor</a> to print
+out the number in the array by accessing the numbers through the array
+of pointers.
+
+<pre>
+  // continuing from previous example...
+
+  const int N = 7;
+  std::vector&lt;int&gt; numbers;
+  // Fill "numbers" array with [0,N)
+  std::copy(boost::make_counting_iterator(0), boost::make_counting_iterator(N),
+	    std::back_inserter(numbers));
+
+  std::vector&lt;std::vector&lt;int&gt;::iterator&gt; pointers;
+
+  // Use counting iterator to fill in the array of pointers.
+  std::copy(boost::make_counting_iterator(numbers.begin()),
+	    boost::make_counting_iterator(numbers.end()),
+	    std::back_inserter(pointers));
+
+  // Use indirect iterator to print out numbers by accessing
+  // them through the array of pointers.
+  std::cout &lt;&lt; "indirectly printing out the numbers from 0 to " 
+	    &lt;&lt; N &lt;&lt; std::endl;
+  std::copy(boost::make_indirect_iterator(pointers.begin()),
+	    boost::make_indirect_iterator(pointers.end()),
+	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+</pre>
+The output is:
+<pre>
+indirectly printing out the numbers from 0 to 7
+0 1 2 3 4 5 6 
+</pre>
+
+<hr>
+
+<h2><a name="counting_iterator_traits">Counting Iterator Traits</a></h2>
+
+The counting iterator adaptor needs to determine the appropriate
+<tt>difference_type</tt> and <tt>iterator_category</tt> to use based on the
+<tt>Incrementable</tt> type supplied by the user.  The
+<tt>counting_iterator_traits</tt> class provides these types.  If the
+<tt>Incrementable</tt> type is an integral type or an iterator, these types
+will be correctly deduced by the <tt>counting_iterator_traits</tt> provided by
+the library. Otherwise, the user must specialize
+<tt>counting_iterator_traits</tt> for her type or add nested typedefs to
+her type to fulfill the needs of
+<a href="http://www.sgi.com/tech/stl/iterator_traits.html">
+<tt>std::iterator_traits</tt></a>.
+
+<p>The following pseudocode describes how the <tt>counting_iterator_traits</tt> are determined:
+
+<pre>
+template &lt;class Incrementable&gt;
+struct counting_iterator_traits
+{
+  if (numeric_limits&lt;Incrementable&gt::is_specialized) {
+    if (!numeric_limits&lt;Incrementable&gt::is_integer)
+       COMPILE_TIME_ERROR;
+
+    if (!numeric_limits&lt;Incrementable&gt::is_bounded
+        &amp;&amp; numeric_limits&lt;Incrementable&gt;::is_signed) {
+        typedef Incrementable difference_type;
+    }
+    else if (numeric_limits&lt;Incrementable&gt::is_integral) {
+        typedef <i>next-larger-signed-type-or-intmax_t</i> difference_type;
+    }
+    typedef std::random_access_iterator_tag iterator_category;   
+  } else {
+    typedef std::iterator_traits&lt;Incrementable&gt;::difference_type difference_type;
+    typedef std::iterator_traits&lt;Incrementable&gt;::iterator_category iterator_category;
+  }
+};
+</pre>
+
+<p>The italicized sections above are implementation details, but it is important
+to know that the <tt>difference_type</tt> for integral types is selected so that
+it can always represent the difference between two values if such a built-in
+integer exists. On platforms with a working <tt>std::numeric_limits</tt>
+implementation, the <tt>difference_type</tt> for any variable-length signed
+integer type <tt>T</tt> is <tt>T</tt> itself.
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->28 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14390" --></p>
+<p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
+modify, sell and distribute this document is granted provided this copyright
+notice appears in all copies. This document is provided &quot;as is&quot;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>
+<!--  LocalWords:  html charset alt gif hpp incrementable const namespace htm
+ -->
+<!--  LocalWords:  struct  typename iostream int Siek CopyConstructible pre
+ -->
+
--- a/counting_iterator_example.cpp
+++ b/counting_iterator_example.cpp
@@ -0,0 +1,53 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+
+#include <boost/config.hpp>
+#include <iostream>
+#include <iterator>
+#include <vector>
+#include <boost/counting_iterator.hpp>
+#include <boost/iterator_adaptors.hpp>
+
+int main(int, char*[])
+{
+  // Example of using counting_iterator_generator
+  std::cout << "counting from 0 to 4:" << std::endl;
+  boost::counting_iterator_generator<int>::type first(0), last(4);
+  std::copy(first, last, std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  // Example of using make_counting_iterator()
+  std::cout << "counting from -5 to 4:" << std::endl;
+  std::copy(boost::make_counting_iterator(-5),
+	    boost::make_counting_iterator(5),
+	    std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  // Example of using counting iterator to create an array of pointers.
+  const int N = 7;
+  std::vector<int> numbers;
+  // Fill "numbers" array with [0,N)
+  std::copy(boost::make_counting_iterator(0), boost::make_counting_iterator(N),
+	    std::back_inserter(numbers));
+
+  std::vector<std::vector<int>::iterator> pointers;
+
+  // Use counting iterator to fill in the array of pointers.
+  std::copy(boost::make_counting_iterator(numbers.begin()),
+	    boost::make_counting_iterator(numbers.end()),
+	    std::back_inserter(pointers));
+
+  // Use indirect iterator to print out numbers by accessing
+  // them through the array of pointers.
+  std::cout << "indirectly printing out the numbers from 0 to " 
+	    << N << std::endl;
+  std::copy(boost::make_indirect_iterator(pointers.begin()),
+	    boost::make_indirect_iterator(pointers.end()),
+	    std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+  
+  return 0;
+}
--- a/counting_iterator_test.cpp
+++ b/counting_iterator_test.cpp
@@ -0,0 +1,263 @@
+// (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears in
+// all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org for most recent version including documentation.
+//
+// Revision History
+// 16 Feb 2001  Added a missing const. Made the tests run (somewhat) with
+//              plain MSVC again. (David Abrahams)
+// 11 Feb 2001  #if 0'd out use of counting_iterator on non-numeric types in
+//              MSVC without STLport, so that the other tests may proceed
+//              (David Abrahams)
+// 04 Feb 2001  Added use of iterator_tests.hpp (David Abrahams)
+// 28 Jan 2001  Removed not_an_iterator detritus (David Abrahams)
+// 24 Jan 2001  Initial revision (David Abrahams)
+
+#include <boost/config.hpp>
+#ifdef BOOST_MSVC
+# pragma warning(disable:4786) // identifier truncated in debug info
+#endif
+
+#include <boost/pending/iterator_tests.hpp>
+#include <boost/counting_iterator.hpp>
+#include <boost/detail/iterator.hpp>
+#include <iostream>
+#include <climits>
+#include <iterator>
+#include <stdlib.h>
+#include <boost/utility.hpp>
+#include <vector>
+#include <list>
+#include <cassert>
+#ifndef BOOST_NO_LIMITS
+# include <limits>
+#endif
+#ifndef BOOST_NO_SLIST
+# include <slist>
+#endif
+
+template <class T> struct is_numeric
+{
+    enum { value = 
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+        std::numeric_limits<T>::is_specialized
+#else
+        // Causes warnings with GCC, but how else can I detect numeric types at
+        // compile-time?
+        (boost::is_convertible<int,T>::value &&
+         boost::is_convertible<T,int>::value)
+#endif
+    };
+};
+
+// Special tests for RandomAccess CountingIterators.
+template <class CountingIterator>
+void category_test(
+    CountingIterator start,
+    CountingIterator finish,
+    std::random_access_iterator_tag)
+{
+    typedef typename
+        boost::detail::iterator_traits<CountingIterator>::difference_type
+        difference_type;
+    difference_type distance = boost::detail::distance(start, finish);
+
+    // Pick a random position internal to the range
+    difference_type offset = (unsigned)rand() % distance;
+    assert(offset >= 0);
+    CountingIterator internal = start;
+    std::advance(internal, offset);
+
+    // Try some binary searches on the range to show that it's ordered
+    assert(std::binary_search(start, finish, *internal));
+    CountingIterator x,y;
+    boost::tie(x,y) = std::equal_range(start, finish, *internal);
+    assert(boost::detail::distance(x, y) == 1);
+
+    // Show that values outside the range can't be found
+    assert(!std::binary_search(start, boost::prior(finish), *finish));
+
+    // Do the generic random_access_iterator_test
+    typedef typename CountingIterator::value_type value_type;
+    std::vector<value_type> v;
+    for (value_type z = *start; z != *finish; ++z)
+        v.push_back(z);
+    if (v.size() >= 2)
+    {
+        // Note that this test requires a that the first argument is
+        // dereferenceable /and/ a valid iterator prior to the first argument
+        boost::random_access_iterator_test(start + 1, v.size() - 1, v.begin() + 1);
+    }
+}
+
+// Special tests for bidirectional CountingIterators
+template <class CountingIterator>
+void category_test(CountingIterator start, CountingIterator finish, std::bidirectional_iterator_tag)
+{
+    if (finish != start
+        && finish != boost::next(start)
+        && finish != boost::next(boost::next(start)))
+    {
+        // Note that this test requires a that the first argument is
+        // dereferenceable /and/ a valid iterator prior to the first argument
+        boost::bidirectional_iterator_test(boost::next(start), boost::next(*start), boost::next(boost::next(*start)));
+    }
+}
+
+template <class CountingIterator>
+void category_test(CountingIterator start, CountingIterator finish, std::forward_iterator_tag)
+{
+    if (finish != start && finish != boost::next(start))
+        boost::forward_iterator_test(start, *start, boost::next(*start));
+}
+
+template <class CountingIterator>
+void test_aux(CountingIterator start, CountingIterator finish)
+{
+    typedef typename CountingIterator::iterator_category category;
+    typedef typename CountingIterator::value_type value_type;
+
+    // If it's a RandomAccessIterator we can do a few delicate tests
+    category_test(start, finish, category());
+    
+    // Okay, brute force...
+    for (CountingIterator p = start; p != finish && boost::next(p) != finish; ++p)
+    {
+        assert(boost::next(*p) == *boost::next(p));
+    }
+
+    // prove that a reference can be formed to these values
+    typedef typename CountingIterator::value_type value;
+    const value* q = &*start;
+    (void)q; // suppress unused variable warning
+}
+
+template <class Incrementable>
+void test(Incrementable start, Incrementable finish)
+{
+    test_aux(boost::make_counting_iterator(start), boost::make_counting_iterator(finish));
+}
+
+template <class Integer>
+void test_integer(Integer* = 0) // default arg works around MSVC bug
+{
+    Integer start = 0;
+    Integer finish = 120;
+    test(start, finish);
+}
+
+template <class Container>
+void test_container(Container* = 0)  // default arg works around MSVC bug
+{
+    Container c(1 + (unsigned)rand() % 1673);
+
+    const typename Container::iterator start = c.begin();
+    
+    // back off by 1 to leave room for dereferenceable value at the end
+    typename Container::iterator finish = start;
+    std::advance(finish, c.size() - 1);
+    
+    test(start, finish);
+
+    typedef typename Container::const_iterator const_iterator;
+    test(const_iterator(start), const_iterator(finish));
+}
+
+class my_int1 {
+public:
+  my_int1() { }
+  my_int1(int x) : m_int(x) { }
+  my_int1& operator++() { ++m_int; return *this; }
+  bool operator==(const my_int1& x) const { return m_int == x.m_int; }
+private:
+  int m_int;
+};
+
+namespace boost {
+  template <>
+  struct counting_iterator_traits<my_int1> {
+    typedef std::ptrdiff_t difference_type;
+    typedef std::forward_iterator_tag iterator_category;
+  };
+}
+
+class my_int2 {
+public:
+  typedef void value_type;
+  typedef void pointer;
+  typedef void reference;
+  typedef std::ptrdiff_t difference_type;
+  typedef std::bidirectional_iterator_tag iterator_category;
+
+  my_int2() { }
+  my_int2(int x) : m_int(x) { }
+  my_int2& operator++() { ++m_int; return *this; }
+  my_int2& operator--() { --m_int; return *this; }
+  bool operator==(const my_int2& x) const { return m_int == x.m_int; }
+private:
+  int m_int;
+};
+
+class my_int3 {
+public:
+  typedef void value_type;
+  typedef void pointer;
+  typedef void reference;
+  typedef std::ptrdiff_t difference_type;
+  typedef std::random_access_iterator_tag iterator_category;
+
+  my_int3() { }
+  my_int3(int x) : m_int(x) { }
+  my_int3& operator++() { ++m_int; return *this; }
+  my_int3& operator+=(std::ptrdiff_t n) { m_int += n; return *this; }
+  std::ptrdiff_t operator-(const my_int3& x) const { return m_int - x.m_int; }
+  my_int3& operator--() { --m_int; return *this; }
+  bool operator==(const my_int3& x) const { return m_int == x.m_int; }
+  bool operator!=(const my_int3& x) const { return m_int != x.m_int; }
+  bool operator<(const my_int3& x) const { return m_int < x.m_int; }
+private:
+  int m_int;
+};
+
+int main()
+{
+    // Test the built-in integer types.
+    test_integer<char>();
+    test_integer<unsigned char>();
+    test_integer<signed char>();
+    test_integer<wchar_t>();
+    test_integer<short>();
+    test_integer<unsigned short>();
+    test_integer<int>();
+    test_integer<unsigned int>();
+    test_integer<long>();
+    test_integer<unsigned long>();
+#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
+    test_integer<long long>();
+    test_integer<unsigned long long>();
+#endif
+
+   // wrapping an iterator or non-built-in integer type causes an INTERNAL
+   // COMPILER ERROR in MSVC without STLport. I'm clueless as to why.
+#if !defined(BOOST_MSVC) || defined(__SGI_STL_PORT)
+    // Test user-defined type.
+    test_integer<my_int1>();
+    test_integer<my_int2>();
+    test_integer<my_int3>();
+    
+   // Some tests on container iterators, to prove we handle a few different categories
+    test_container<std::vector<int> >();
+    test_container<std::list<int> >();
+# ifndef BOOST_NO_SLIST
+    test_container<BOOST_STD_EXTENSION_NAMESPACE::slist<int> >();
+# endif
+    
+    // Also prove that we can handle raw pointers.
+    int array[2000];
+    test(boost::make_counting_iterator(array), boost::make_counting_iterator(array+2000-1));
+#endif
+    std::cout << "test successful " << std::endl;
+    return 0;
+}
--- a/filter_iterator.htm
+++ b/filter_iterator.htm
@@ -0,0 +1,273 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<title>Filter Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+align="center" width="277" height="86">
+
+<h1>Filter Iterator Adaptor</h1>
+
+Defined in header
+<a href="../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
+
+
+<p>
+The filter iterator adaptor creates a view of an iterator range in
+which some elements of the range are skipped over. A <a
+href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>
+function object controls which elements are skipped. When the
+predicate is applied to an element, if it returns <tt>true</tt> then
+the element is retained and if it returns <tt>false</tt> then the
+element is skipped over.
+
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;class Predicate, class BaseIterator, ...&gt;
+  class filter_iterator_generator;
+
+  template &lt;class Predicate, class BaseIterator&gt;
+  typename filter_iterator_generator&lt;Predicate, BaseIterator&gt;::type
+  make_filter_iterator(BaseIterator first, BaseIterator last, const Predicate& p = Predicate());
+}
+</pre>
+
+<hr>
+
+<h2><a name="filter_iterator_generator">The Filter Iterator Type
+Generator</a></h2>
+
+The class <tt>filter_iterator_generator</tt> is a helper class whose
+purpose is to construct a filter iterator type.  The template
+parameters for this class are the <tt>Predicate</tt> function object
+type and the <tt>BaseIterator</tt> type that is being wrapped.  In
+most cases the associated types for the wrapped iterator can be
+deduced from <tt>std::iterator_traits</tt>, but in some situations the
+user may want to override these types, so there are also template
+parameters for each of the iterator's associated types.
+
+<pre>
+template &lt;class Predicate, class BaseIterator,
+          class Value, class Reference, class Pointer, class Category, class Distance>
+class filter_iterator_generator
+{
+public:
+  typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt;</tt> type; // the resulting filter iterator type 
+}
+</pre>
+
+
+<h3>Example</h3>
+
+The following example uses filter iterator to print out all the
+positive integers in an array. 
+
+<pre>
+struct is_positive_number {
+  bool operator()(int x) { return 0 &lt; x; }
+};
+int main() {
+  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
+  const int N = sizeof(numbers)/sizeof(int);
+
+  typedef boost::filter_iterator_generator&lt;is_positive_number, int*, int&gt;::type FilterIter;
+  is_positive_number predicate;
+  FilterIter::policies_type policies(predicate, numbers + N);
+  FilterIter filter_iter_first(numbers, policies);
+  FilterIter filter_iter_last(numbers + N, policies);
+
+  std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+  return 0;
+}
+</pre>
+The output is:
+<pre>
+4 5 8
+</pre>
+
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><a href="http://www.sgi.com/tech/stl/Predicate.html"><tt>Predicate</tt></a></TD>
+<TD>The function object that determines which elements are retained and which elements are skipped.
+</TR>
+
+<TR>
+<TD><tt>BaseIterator</tt></TD>
+<TD>The iterator type being wrapped. This type must at least be a model
+ of the <a href="http://www.sgi.com/tech/stl/InputIterator">InputIterator</a> concept.</TD>
+</TR>
+
+<TR>
+<TD><tt>Value</tt></TD>
+<TD>The <tt>value_type</tt> of the resulting iterator,
+unless const. If const, a conforming compiler strips constness for the
+<tt>value_type</tt>. Typically the default for this parameter is the
+appropriate type<a href="#1">[1]</a>.<br> <b>Default:</b>
+<tt>std::iterator_traits&lt;BaseIterator&gt;::value_type</TD>
+</TR>
+
+<TR>
+<TD><tt>Reference</tt></TD>
+<TD>The <tt>reference</tt> type of the resulting iterator, and in
+particular, the result type of <tt>operator*()</tt>. Typically the default for
+this parameter is the appropriate type.<br> <b>Default:</b> If
+<tt>Value</tt> is supplied, <tt>Value&amp;</tt> is used. Otherwise
+<tt>std::iterator_traits&lt;BaseIterator&gt;::reference</tt> is
+used.</TD>
+</TR>
+
+<TR>
+<TD><tt>Pointer</tt></TD>
+<TD>The <tt>pointer</tt> type of the resulting iterator, and in
+ particular, the result type of <tt>operator->()</tt>. 
+ Typically the default for
+this parameter is the appropriate type.<br>
+<b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
+otherwise <tt>std::iterator_traits&lt;BaseIterator&gt;::pointer</tt>.</TD>
+</TR>
+
+
+<TR>
+<TD><tt>Category</tt></TD>
+<TD>The <tt>iterator_category</tt> type for the resulting iterator.
+Typically the
+default for this parameter is the appropriate type. If you override
+this parameter, do not use <tt>bidirectional_iterator_tag</tt>
+because filter iterators can not go in reverse.<br>
+<b>Default:</b> <tt>std::iterator_traits&lt;BaseIterator&gt;::iterator_category</tt></TD>
+</TR>
+
+<TR>
+<TD><tt>Distance</tt></TD>
+<TD>The <tt>difference_type</tt> for the resulting iterator. Typically the default for
+this parameter is the appropriate type.<br>
+<b>Default:</b> <tt>std::iterator_traits&lt;BaseIterator&gt;::difference_type</TD>
+</TR>
+
+</table>
+
+
+<h3>Model of</h3>
+
+The filter iterator adaptor (the type
+<tt>filter_iterator_generator<...>::type</tt>) may be a model of <a
+href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a> or <a
+href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>
+depending on the adapted iterator type.
+
+
+<h3>Members</h3>
+
+The filter iterator type implements all of the member functions and
+operators required of the <a
+href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>
+concept.  In addition it has the following constructor:
+
+<pre>filter_iterator_generator::type(const BaseIterator& it, const Policies& p = Policies())</pre>
+
+<p>
+The policies type has only one public function, which is its constructor:
+
+<pre>filter_iterator_generator::policies_type(const Predicate& p, const BaseIterator& end)</pre>
+
+<p>
+<hr>
+<p>
+
+<h2><a name="make_filter_iterator">The Make Filter Iterator Function</a></h2>
+
+<pre>
+template &lt;class Predicate, class BaseIterator&gt;
+typename detail::filter_generator&lt;Predicate, BaseIterator&gt;::type
+make_filter_iterator(BaseIterator first, BaseIterator last, const Predicate& p = Predicate())
+</pre>
+
+This function provides a convenient way to create filter iterators.
+
+<h3>Example</h3>
+
+In this example we print out all numbers in the array that are
+greater than negative two.
+
+<pre>
+int main()
+{
+  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
+  const int N = sizeof(numbers)/sizeof(int);
+
+  std::copy(boost::make_filter_iterator(numbers, numbers + N, 
+					std::bind2nd(std::greater<int>(), -2)),
+	    boost::make_filter_iterator(numbers + N, numbers + N, 
+					std::bind2nd(std::greater<int>(), -2)),
+	    std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+}
+</pre>
+The output is:
+<pre>
+0 -1 4 5 8 
+</pre>
+
+<p>
+In the next example we print the positive numbers using the
+<tt>make_filter_iterator()</tt> function.
+
+<pre>
+struct is_positive_number {
+  bool operator()(int x) { return 0 &lt; x; }
+};
+int main()
+{
+  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
+  const int N = sizeof(numbers)/sizeof(int);
+
+  std::copy(boost::make_filter_iterator&lt;is_positive_number&gt;(numbers, numbers + N),
+	    boost::make_filter_iterator&lt;is_positive_number&gt;(numbers + N, numbers + N),
+	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+  return 0;
+}
+</pre>
+The output is:
+<pre>
+4 5 8
+</pre>
+
+
+<h3>Notes</h3>
+
+<a name="1">[1]</a> If the compiler does not support partial
+specialization and the wrapped iterator type is a builtin pointer then
+the <tt>Value</tt> type must be explicitly specified (don't use the
+default).
+
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->09 Mar 2001<!--webbot bot="Timestamp" endspan i-checksum="14894" --></p>
+<p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
+modify, sell and distribute this document is granted provided this copyright
+notice appears in all copies. This document is provided &quot;as is&quot;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>
--- a/filter_iterator_example.cpp
+++ b/filter_iterator_example.cpp
@@ -0,0 +1,53 @@
+// Example of using the filter iterator adaptor from
+// boost/iterator_adaptors.hpp.
+
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+
+#include <boost/config.hpp>
+#include <algorithm>
+#include <functional>
+#include <iostream>
+#include <boost/iterator_adaptors.hpp>
+
+struct is_positive_number {
+  bool operator()(int x) { return 0 < x; }
+};
+
+int main()
+{
+  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
+  const int N = sizeof(numbers)/sizeof(int);
+
+  // Example using make_filter_iterator()
+  std::copy(boost::make_filter_iterator<is_positive_number>(numbers, numbers + N),
+	    boost::make_filter_iterator<is_positive_number>(numbers + N, numbers + N),
+	    std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  // Example using filter_iterator_generator
+  typedef boost::filter_iterator_generator<is_positive_number, int*, int>::type
+    FilterIter;
+  is_positive_number predicate;
+  FilterIter::policies_type policies(predicate, numbers + N);
+  FilterIter filter_iter_first(numbers, policies);
+  FilterIter filter_iter_last(numbers + N, policies);
+
+  std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  // Another example using make_filter_iterator()
+  std::copy(boost::make_filter_iterator(numbers, numbers + N, 
+					std::bind2nd(std::greater<int>(), -2)),
+	    boost::make_filter_iterator(numbers + N, numbers + N, 
+					std::bind2nd(std::greater<int>(), -2)),
+	    std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+  
+  
+  return 0;
+}
--- a/fun_out_iter_example.cpp
+++ b/fun_out_iter_example.cpp
@@ -0,0 +1,41 @@
+// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
+// sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+// Revision History:
+
+// 27 Feb 2001   Jeremy Siek
+//      Initial checkin.
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <boost/function_output_iterator.hpp>
+
+struct string_appender {
+  string_appender(std::string& s) : m_str(s) { }
+  void operator()(const std::string& x) const {
+    m_str += x;
+  }
+  std::string& m_str;
+};
+
+int main(int, char*[])
+{
+  std::vector<std::string> x;
+  x.push_back("hello");
+  x.push_back(" ");
+  x.push_back("world");
+  x.push_back("!");
+
+  std::string s = "";
+  std::copy(x.begin(), x.end(), 
+	    boost::make_function_output_iterator(string_appender(s)));
+  
+  std::cout << s << std::endl;
+
+  return 0;
+}
--- a/function_output_iterator.htm
+++ b/function_output_iterator.htm
@@ -0,0 +1,169 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+
+<html>
+<head>
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+    <meta name="ProgId" content="FrontPage.Editor.Document">
+
+    <title>Function Output Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+        
+    <img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
+    "center" width="277" height="86"> 
+
+    <h1>Function Output Iterator Adaptor</h1>
+    Defined in header <a href=
+    "../../boost/function_output_iterator.hpp">boost/function_output_iterator.hpp</a> 
+
+    <p>The function output iterator adaptor makes it easier to create
+    custom output iterators. The adaptor takes a <a
+    href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
+    Function</a> and creates a model of <a
+    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
+    Iterator</a>. Each item assigned to the output iterator is passed
+    as an argument to the unary function.  The motivation for this
+    iterator is that creating a C++ Standard conforming output
+    iterator is non-trivial, particularly because the proper
+    implementation usually requires a proxy object. On the other hand,
+    creating a function (or function object) is much simpler.
+
+    <h2>Synopsis</h2>
+
+    <blockquote>
+<pre>
+namespace boost {
+  template &lt;class UnaryFunction&gt;
+  class function_output_iterator;
+
+  template &lt;class UnaryFunction&gt;
+  function_output_iterator&lt;UnaryFunction&gt;
+  make_function_output_iterator(const UnaryFunction&amp; f = UnaryFunction())
+}
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    
+    In this example we create an output iterator that appends
+    each item onto the end of a string, using the <tt>string_appender</tt>
+    function. 
+
+    <blockquote>
+<pre>
+#include &lt;iostream&gt;
+#include &lt;string&gt;
+#include &lt;vector&gt;
+
+#include &lt;boost/function_output_iterator.hpp&gt;
+
+struct string_appender {
+  string_appender(std::string&amp; s) : m_str(s) { }
+  void operator()(const std::string&amp; x) const {
+    m_str += x;
+  }
+  std::string&amp; m_str;
+};
+
+int main(int, char*[])
+{
+  std::vector&lt;std::string&gt; x;
+  x.push_back("hello");
+  x.push_back(" ");
+  x.push_back("world");
+  x.push_back("!");
+
+  std::string s = "";
+  std::copy(x.begin(), x.end(), 
+            boost::make_function_output_iterator(string_appender(s)));
+  
+  std::cout &lt;&lt; s &lt;&lt; std::endl;
+
+  return 0;
+}
+</pre>
+    </blockquote>
+
+    <hr>
+
+    <h2><a name="function_output_iterator">The Function Output Iterator Class</a></h2>
+
+    <blockquote>
+<pre>
+template &lt;class UnaryFunction&gt;
+class function_output_iterator;
+</pre>
+    </blockquote>
+
+    The <tt>function_output_iterator</tt> class creates an <a
+    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
+    Iterator</a> out of a
+    <a href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
+    Function</a>. Each item assigned to the output iterator is passed
+    as an argument to the unary function.
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>UnaryFunction</tt> 
+
+        <td>The function type being wrapped. The return type of the
+        function is not used, so it can be <tt>void</tt>.  The
+        function must be a model of <a
+        href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
+        Function</a>.</td>
+    </table>
+
+    <h3>Concept Model</h3>
+    The function output iterator class is a model of <a
+    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
+    Iterator</a>.
+
+    <h2>Members</h3>
+    The function output iterator implements the member functions
+    and operators required of the <a
+    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
+    Iterator</a> concept. In addition it has the following constructor:
+<pre>
+explicit function_output_iterator(const UnaryFunction& f = UnaryFunction())
+</pre>
+   <br>    
+    <br>
+
+    <hr>
+    <h2><a name="make_function_output_iterator">The Function Output Iterator Object
+    Generator</a></h2>
+
+    The <tt>make_function_output_iterator()</tt> function provides a
+    more convenient way to create function output iterator objects. The
+    function saves the user the trouble of explicitly writing out the
+    iterator types. If the default argument is used, the function
+    type must be provided as an explicit template argument.
+
+    <blockquote>
+<pre>
+template &lt;class UnaryFunction&gt;
+function_output_iterator&lt;UnaryFunction&gt;
+make_function_output_iterator(const UnaryFunction&amp; f = UnaryFunction())
+</pre>
+    </blockquote>
+
+    <hr>
+
+    <p>&copy; Copyright Jeremy Siek 2001. Permission to copy, use,
+    modify, sell and distribute this document is granted provided this
+    copyright notice appears in all copies. This document is provided
+    "as is" without express or implied warranty, and with no claim as
+    to its suitability for any purpose.
+
+</body>
+</html>
--- a/half_open_range_test.cpp
+++ b/half_open_range_test.cpp
@@ -0,0 +1,366 @@
+// (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears in
+// all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org for most recent version including documentation.
+//
+// Revision History
+// 11 Feb 2001  Compile with Borland, re-enable failing tests (David Abrahams)
+// 29 Jan 2001  Initial revision (David Abrahams)
+
+#include <boost/half_open_range.hpp>
+#include <boost/utility.hpp>
+#include <iterator>
+#include <stdlib.h>
+#include <vector>
+#include <list>
+#include <cassert>
+#include <stdexcept>
+#ifndef BOOST_NO_LIMITS
+# include <limits>
+#endif
+#ifndef BOOST_NO_SLIST
+# include <slist>
+#endif
+
+inline unsigned unsigned_random(unsigned max)
+{
+    return (max > 0) ? (unsigned)rand() % max : 0;
+}
+
+// Special tests for ranges supporting random access
+template <class T>
+void category_test_1(
+    const boost::half_open_range<T>& r, std::random_access_iterator_tag)
+{
+    typedef boost::half_open_range<T> range;
+    typedef typename range::size_type size_type;
+    size_type size = r.size();
+
+    // pick a random offset
+    size_type offset = unsigned_random(size);
+
+    typename range::value_type x = *(r.begin() + offset);
+    // test contains(value_type)
+    assert(r.contains(r.start()) == !r.empty());
+    assert(!r.contains(r.finish()));
+    assert(r.contains(x) == (offset != size));
+
+    range::const_iterator p = r.find(x);
+    assert((p == r.end()) == (x == r.finish()));
+    assert(r.find(r.finish()) == r.end());
+
+    if (offset != size)
+    {
+        assert(x == r[offset]);
+        assert(x == r.at(offset));
+    }
+
+    bool caught_out_of_range = false;
+    try {
+        bool never_initialized = x == r.at(size);
+        (void)never_initialized;
+    }
+    catch(std::out_of_range&)
+    {
+        caught_out_of_range = true;
+    }
+    catch(...)
+    {
+    }
+    assert(caught_out_of_range);
+}
+
+// Those tests must be skipped for other ranges
+template <class T>
+void category_test_1(
+    const boost::half_open_range<T>&, std::forward_iterator_tag)
+{
+}
+
+unsigned indices[][2] = { {0,0},{0,1},{0,2},{0,3},
+                                {1,1},{1,2},{1,3},
+                                      {2,2},{2,3},
+                                            {3,3}};
+
+template <class Range>
+void category_test_2(
+    const std::vector<Range>& ranges, unsigned i, unsigned j, std::random_access_iterator_tag)
+{
+    typedef Range range;
+    const range& ri = ranges[i];
+    const range& rj = ranges[j];
+
+    if (indices[i][0] <= indices[j][0] && indices[i][1] >= indices[j][1])
+        assert(ri.contains(rj));
+
+    if (ri.contains(rj))
+        assert((ri & rj) == rj);
+    assert(boost::intersects(ri, rj) == !(ri & rj).empty());
+
+    range t1(ri);
+    t1 &= rj;
+    assert(t1 == range(indices[i][0] > indices[j][0] ? ri.start() : rj.start(),
+                       indices[i][1] < indices[j][1] ? ri.finish() : rj.finish()));
+    assert(t1 == (ri & rj));
+    
+    range t2(ri);
+    t2 |= rj;
+    
+    if (ri.empty())
+        assert(t2 == rj);
+    else if (rj.empty())
+        assert(t2 == ri);
+    else
+        assert(t2 == range(indices[i][0] < indices[j][0] ? ri.start() : rj.start(),
+                           indices[i][1] > indices[j][1] ? ri.finish() : rj.finish()));
+    assert(t2 == (ri | rj));
+    if (i == j)
+        assert(ri == rj);
+    
+    if (ri.empty() || rj.empty())
+        assert((ri == rj) == (ri.empty() && rj.empty()));
+    else
+        assert((ri == rj) == (ri.start() == rj.start() && ri.finish() == rj.finish()));
+
+    assert((ri == rj) == !(ri != rj));
+
+    bool same = ri == rj;
+    bool one_empty = ri.empty() != rj.empty();
+
+    std::less<range> less;
+    std::less_equal<range> less_equal;
+    std::greater<range> greater;
+    std::greater_equal<range> greater_equal;
+    
+    if (same)
+    {
+        assert(greater_equal(ri,rj));
+        assert(less_equal(ri,rj));
+        assert(!greater(ri,rj));
+        assert(!less(ri,rj));
+    }
+    else if (one_empty)
+    {
+        const range& empty = ri.empty() ? ri : rj;
+        const range& non_empty = rj.empty() ? ri : rj;
+        
+        assert(less(empty,non_empty));
+        assert(less_equal(empty,non_empty));
+        assert(!greater(empty,non_empty));
+        assert(!greater_equal(empty,non_empty));
+        assert(!less(non_empty,empty));
+        assert(!less_equal(non_empty,empty));
+        assert(greater(non_empty,empty));
+        assert(greater_equal(non_empty,empty));
+    }
+    else {
+        if (indices[i][0] < indices[j][0] ||
+            indices[i][0] == indices[j][0] && indices[i][1] < indices[j][1])
+        {
+            assert(!greater_equal(ri,rj));
+            assert(less(ri,rj));
+        }
+
+        if (indices[i][0] < indices[j][0] ||
+            indices[i][0] == indices[j][0] && indices[i][1] <= indices[j][1])
+        {
+            assert(!greater(ri,rj));
+            assert(less_equal(ri,rj));
+        }
+
+        if (indices[i][0] > indices[j][0] ||
+            indices[i][0] == indices[j][0] && indices[i][1] > indices[j][1])
+        {
+            assert(!less_equal(ri,rj));
+            assert(greater(ri,rj));
+        }
+
+        if (indices[i][0] > indices[j][0] ||
+            indices[i][0] == indices[j][0] && indices[i][1] >= indices[j][1])
+        {
+            assert(!less(ri,rj));
+            assert(greater_equal(ri,rj));
+        }
+    }
+}
+
+
+template <class Range>
+void category_test_2(
+    const std::vector<Range>&, unsigned, unsigned, std::forward_iterator_tag)
+{
+}
+
+template <class T>
+void category_test_2(
+    const std::vector<boost::half_open_range<T> >&, unsigned, unsigned, std::bidirectional_iterator_tag)
+{
+}
+
+template <class Range>
+void test_back(Range& x, std::bidirectional_iterator_tag)
+{
+    assert(x.back() == boost::prior(x.finish()));
+}
+
+template <class Range>
+void test_back(Range& x, std::forward_iterator_tag)
+{
+}
+
+template <class T>
+boost::half_open_range<T> range_identity(const boost::half_open_range<T>& x)
+{
+    return x;
+}
+
+template <class T>
+void test(T x0, T x1, T x2, T x3)
+{
+    std::vector<boost::half_open_range<T> > ranges;
+    typedef boost::half_open_range<T> range;
+
+    T bounds[4] = { x0, x1, x2, x3 };
+
+    const std::size_t num_ranges = sizeof(indices)/sizeof(*indices);
+    // test construction
+    for (std::size_t n = 0; n < num_ranges;++n)
+    {
+        T start = bounds[indices[n][0]];
+        T finish = bounds[indices[n][1]];
+        boost::half_open_range<T> r(start, finish);
+        ranges.push_back(r);
+    }
+    
+    // test implicit conversion from std::pair<T,T>
+    range converted = std::pair<T,T>(x0,x0);
+    (void)converted;
+
+    // test assignment, equality and inequality
+    range r00 = range(x0, x0);
+    assert(r00 == range(x0,x0));
+    assert(r00 == range(x1,x1)); // empty ranges are all equal
+    if (x3 != x0)
+        assert(r00 != range(x0, x3));
+    r00 = range(x0, x3);
+    assert(r00 == range(x0, x3));
+    if (x3 != x0)
+        assert(r00 != range(x0, x0));
+
+    typedef typename range::iterator iterator;
+    typedef typename iterator::iterator_category category;
+    
+    for (unsigned i = 0; i < num_ranges; ++i)
+    {
+        const range& r = ranges[i];
+            
+        // test begin(), end(), basic iteration.
+        unsigned count = 0;
+        for (range::const_iterator p = r.begin(), finish = r.end();
+             p != finish;
+             ++p, ++count)
+        {
+            assert(count < 2100);
+        }
+
+        // test size(), empty(), front(), back()
+        assert((unsigned)r.size() == count);
+        if (indices[i][0] == indices[i][1])
+            assert(r.empty());
+        if (r.empty())
+            assert(r.size() == 0);
+        if (!r.empty())
+        {
+            assert(r.front() == r.start());
+            test_back(r, category());
+        }
+
+            // test swap
+        range r1(r);
+        range r2(x0,x3);
+        const bool same = r1 == r2;
+        r1.swap(r2);
+        assert(r1 == range(x0,x3));
+        assert(r2 == r);
+        if (!same) {
+            assert(r1 != r);
+            assert(r2 != range(x0,x3));
+        }
+
+        // do individual tests for random-access iterators
+        category_test_1(r, category());
+    }
+
+    for (unsigned j = 0; j < num_ranges; ++j) {
+        for (unsigned k = 0; k < num_ranges; ++k) {
+            category_test_2(ranges, j, k, category());
+        }
+    }
+    
+}
+
+template <class Integer>
+void test_integer(Integer* = 0) // default arg works around MSVC bug
+{
+    Integer a = 0;
+    Integer b = a + unsigned_random(128 - a);
+    Integer c = b + unsigned_random(128 - b);
+    Integer d = c + unsigned_random(128 - c);
+
+    test(a, b, c, d);
+}
+
+template <class Container>
+void test_container(Container* = 0)  // default arg works around MSVC bug
+{
+    Container c(unsigned_random(1673));
+
+    const typename Container::size_type offset1 = unsigned_random(c.size());
+    const typename Container::size_type offset2 = unsigned_random(c.size() - offset1);
+    typename Container::iterator internal1 = c.begin();
+    std::advance(internal1, offset1);
+    typename Container::iterator internal2 = internal1;
+    std::advance(internal2, offset2);
+    
+    test(c.begin(), internal1, internal2, c.end());
+
+    typedef typename Container::const_iterator const_iterator;
+    test(const_iterator(c.begin()),
+         const_iterator(internal1),
+         const_iterator(internal2),
+         const_iterator(c.end()));
+}
+
+int main()
+{
+    // Test the built-in integer types.
+    test_integer<char>();
+    test_integer<unsigned char>();
+    test_integer<signed char>();
+    test_integer<wchar_t>();
+    test_integer<short>();
+    test_integer<unsigned short>();
+    test_integer<int>();
+    test_integer<unsigned int>();
+    test_integer<long>();
+    test_integer<unsigned long>();
+#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
+    test_integer<long long>();
+    test_integer<unsigned long long>();
+#endif
+    // Some tests on container iterators, to prove we handle a few different categories
+    test_container<std::vector<int> >();
+    test_container<std::list<int> >();
+#ifndef BOOST_NO_SLIST
+    test_container<BOOST_STD_EXTENSION_NAMESPACE::slist<int> >();
+#endif
+    // Also prove that we can handle raw pointers.
+    int array[2000];
+    const std::size_t a = 0;
+    const std::size_t b = a + unsigned_random(2000 - a);
+    const std::size_t c = b + unsigned_random(2000 - b);
+    test(array, array+b, array+c, array+2000);
+    return 0;
+}
--- a/include/boost/detail/call_traits.hpp
+++ b/include/boost/detail/call_traits.hpp
@@ -23,8 +23,11 @@
 #include <boost/config.hpp>
 #endif

-#ifndef BOOST_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
+#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
+#include <boost/type_traits/arithmetic_traits.hpp>
+#endif
+#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
+#include <boost/type_traits/composite_traits.hpp>
 #endif

 namespace boost{
--- a/include/boost/detail/compressed_pair.hpp
+++ b/include/boost/detail/compressed_pair.hpp
@@ -19,8 +19,11 @@
 #define BOOST_DETAIL_COMPRESSED_PAIR_HPP

 #include <algorithm>
-#ifndef BOOST_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
+#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
+#include <boost/type_traits/object_traits.hpp>
+#endif
+#ifndef BOOST_SAME_TRAITS_HPP
+#include <boost/type_traits/same_traits.hpp>
 #endif
 #ifndef BOOST_CALL_TRAITS_HPP
 #include <boost/call_traits.hpp>
@@ -75,7 +78,9 @@ namespace details
   template <typename T>
   inline void cp_swap(T& t1, T& t2)
   {
+#ifndef __GNUC__
      using std::swap;
+#endif
      swap(t1, t2);
   }

@@ -420,3 +425,4 @@ swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
 #endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP


+
--- a/include/boost/detail/ob_call_traits.hpp
+++ b/include/boost/detail/ob_call_traits.hpp
@@ -9,6 +9,14 @@
 //  Crippled version for crippled compilers:
 //  see libs/utility/call_traits.htm
 //
+
+/* Release notes:
+   01st October 2000:
+      Fixed call_traits on VC6, using "poor man's partial specialisation",
+      using ideas taken from "Generative programming" by Krzysztof Czarnecki 
+      & Ulrich Eisenecker.
+*/
+
 #ifndef BOOST_OB_CALL_TRAITS_HPP
 #define BOOST_OB_CALL_TRAITS_HPP

@@ -16,12 +24,94 @@
 #include <boost/config.hpp>
 #endif

-#ifndef BOOST_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
+#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
+#include <boost/type_traits/arithmetic_traits.hpp>
+#endif
+#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
+#include <boost/type_traits/composite_traits.hpp>
 #endif

 namespace boost{

+#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
 {
@@ -31,6 +121,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
@@ -8,6 +8,12 @@
 //  see libs/utility/compressed_pair.hpp
 //
 /* Release notes:
+   20 Jan 2001:
+        Fixed obvious bugs (David Abrahams)
+	07 Oct 2000:
+		Added better single argument constructor support.
+   03 Oct 2000:
+      Added VC6 support (JM).
   23rd July 2000:
      Additional comments added. (JM)
   Jan 2000:
@@ -20,8 +26,11 @@
 #define BOOST_OB_COMPRESSED_PAIR_HPP

 #include <algorithm>
-#ifndef BOOST_TYPE_TRAITS_HPP
-#include <boost/type_traits.hpp>
+#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
+#include <boost/type_traits/object_traits.hpp>
+#endif
+#ifndef BOOST_SAME_TRAITS_HPP
+#include <boost/type_traits/same_traits.hpp>
 #endif
 #ifndef BOOST_CALL_TRAITS_HPP
 #include <boost/call_traits.hpp>
@@ -29,6 +38,424 @@

 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_conversion_traits
+{
+   typedef char one;
+   typedef char (&two)[2];
+   static A a;
+   static one test(T1);
+   static two test(T2);
+
+   enum { value = sizeof(test(a)) };
+};
+
+template <int>
+struct init_one;
+
+template <>
+struct init_one<1>
+{
+   template <class A, class T1, class T2>
+   static void init(const A& a, T1* p1, T2*)
+   {
+      *p1 = a;
+   }
+};
+
+template <>
+struct init_one<2>
+{
+   template <class A, class T1, class T2>
+   static void init(const A& a, T1*, T2* p2)
+   {
+      *p2 = a;
+   }
+};
+
+
+// T1 != T2, both non-empty
+template <class T1, class T2>
+class compressed_pair_0
+{
+private:
+   T1 _first;
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_0() : _first(), _second() {}
+            compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
+   template <class A>
+   explicit compressed_pair_0(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
+   }
+   compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
+      : _first(x.first()), _second(x.second()) {}
+
+#if 0
+  compressed_pair_0& operator=(const compressed_pair_0& x) {
+    cout << "assigning compressed pair 0" << endl;
+    _first = x._first;
+    _second = x._second;
+    cout << "finished assigning compressed pair 0" << endl;
+    return *this;
+  }
+#endif
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair_0& y)
+   {
+      using std::swap;
+      swap(_first, y._first);
+      swap(_second, y._second);
+   }
+};
+
+// T1 != T2, T2 empty
+template <class T1, class T2>
+class compressed_pair_1 : T2
+{
+private:
+   T1 _first;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_1() : T2(), _first() {}
+            compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}
+
+   template <class A>
+   explicit compressed_pair_1(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
+   }
+
+   compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
+      : T2(x.second()), _first(x.first()) {}
+
+#ifdef BOOST_MSVC
+  // Total weirdness. If the assignment to _first is moved after
+  // the call to the inherited operator=, then this breaks graph/test/graph.cpp
+  // by way of iterator_adaptor.
+  compressed_pair_1& operator=(const compressed_pair_1& x) {
+    _first = x._first;
+    T2::operator=(x);
+    return *this;
+  }
+#endif
+
+   first_reference       first()       { return _first; }
+   first_const_reference first() const { return _first; }
+
+   second_reference       second()       { return *this; }
+   second_const_reference second() const { return *this; }
+
+   void swap(compressed_pair_1& y)
+   {
+      // no need to swap empty base class:
+      using std::swap;
+      swap(_first, y._first);
+   }
+};
+
+// T1 != T2, T1 empty
+template <class T1, class T2>
+class compressed_pair_2 : T1
+{
+private:
+   T2 _second;
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_2() : T1(), _second() {}
+            compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
+   template <class A>
+   explicit compressed_pair_2(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
+   }
+   compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
+      : T1(x.first()), _second(x.second()) {}
+
+#if 0
+  compressed_pair_2& operator=(const compressed_pair_2& x) {
+    cout << "assigning compressed pair 2" << endl;
+    T1::operator=(x);
+    _second = x._second;
+    cout << "finished assigning compressed pair 2" << endl;
+    return *this;
+  }
+#endif
+   first_reference       first()       { return *this; }
+   first_const_reference first() const { return *this; }
+
+   second_reference       second()       { return _second; }
+   second_const_reference second() const { return _second; }
+
+   void swap(compressed_pair_2& y)
+   {
+      // no need to swap empty base class:
+      using std::swap;
+      swap(_second, y._second);
+   }
+};
+
+// T1 != T2, both empty
+template <class T1, class T2>
+class compressed_pair_3 : T1, T2
+{
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_3() : T1(), T2() {}
+            compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
+   template <class A>
+   explicit compressed_pair_3(const A& val)
+   {
+      init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));
+   }
+   compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
+      : T1(x.first()), T2(x.second()) {}
+
+   first_reference       first()       { return *this; }
+   first_const_reference first() const { return *this; }
+
+   second_reference       second()       { return *this; }
+   second_const_reference second() const { return *this; }
+
+   void swap(compressed_pair_3& y)
+   {
+      // no need to swap empty base classes:
+   }
+};
+
+// T1 == T2, and empty
+template <class T1, class T2>
+class compressed_pair_4 : T1
+{
+public:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   typedef typename call_traits<first_type>::reference        first_reference;
+   typedef typename call_traits<second_type>::reference       second_reference;
+   typedef typename call_traits<first_type>::const_reference  first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair_4() : T1() {}
+            compressed_pair_4(first_param_type x, second_param_type) : 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<T1,T2>& x)
+      : T1(x.first()){}
+
+   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
@@ -72,7 +499,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
@@ -15,6 +15,8 @@
 //  See http://www.boost.org for most recent version including documentation.

 //  Revision History
+//  11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
+//            supplied arguments from actually being used (Dave Abrahams)
 //  04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
 //            refactoring of compiler workarounds, additional documentation
 //            (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
@@ -69,6 +71,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 {

@@ -510,7 +516,7 @@ struct forward_iterator_helper
  : equality_comparable<T
  , incrementable<T
  , dereferenceable<T,P
-  , boost::iterator<std::forward_iterator_tag, V, D
+  , boost::iterator<std::forward_iterator_tag,V,D,P,R
    > > > > {};

 template <class T,
@@ -523,7 +529,7 @@ struct bidirectional_iterator_helper
  , incrementable<T
  , decrementable<T
  , dereferenceable<T,P
-  , boost::iterator<std::bidirectional_iterator_tag, V, D
+  , boost::iterator<std::bidirectional_iterator_tag,V,D,P,R
    > > > > > {};

 template <class T,
@@ -540,7 +546,7 @@ struct random_access_iterator_helper
  , addable2<T,D
  , subtractable2<T,D
  , indexable<T,D,R
-  , boost::iterator<std::random_access_iterator_tag, V, D
+  , boost::iterator<std::random_access_iterator_tag,V,D,P,R
    > > > > > > > > >
 {
 #ifndef __BORLANDC__
--- 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/index.htm
+++ b/index.htm
@@ -1,72 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<title>Boost Utility Library</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<table border="1" cellpadding="2" bgcolor="#007F7F">
-  <tr>
-    <td bgcolor="#FFFFFF"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
-    <td><a href="../../index.htm"><font color="#FFFFFF" size="4" face="Arial">Home</font></a></td>
-    <td><a href="../../libraries.htm"><font color="#FFFFFF" size="4" face="Arial">Libraries</font></a></td>
-    <td><a href="../../people.htm"><font color="#FFFFFF" size="4" face="Arial">People</font></a></td>
-    <td><a href="../../more/faq.htm"><font color="#FFFFFF" size="4" face="Arial">FAQ</font></a></td>
-    <td><a href="../../more/index.htm"><font color="#FFFFFF" size="4" face="Arial">More</font></a></td>
-  </tr>
-</table>
-<h1>Boost Utility Library</h1>
-<table border="1" cellpadding="5">
-  <tr>
-    <td><b><i>Header</i></b></td>
-    <td><b><i>Contents</i></b></td>
-  </tr>
-  <tr>
-    <td><a href="../../boost/utility.hpp"><code>boost/utility.hpp<br>
-      </code></a><a href="utility.htm">[Documentation]</a></td>
-    <td>Class <b>noncopyable</b> plus <b>next()</b> and <b>prior()</b> template
-      functions.</td>
-  </tr>
-  <tr>
-    <td><a href="../../boost/cast.hpp"><code>boost/cast.hpp</code></a><br>
-      <a href="cast.htm">[Documentation]</a></td>
-    <td><b>polymorphic_cast</b>, <b>implicit_cast</b>, and <b>numeric_cast</b>
-      function templates.
-      <p><i>[Beta.]</i></p>
-    </td>
-  </tr>
-  <tr>
-    <td><a href="../../boost/operators.hpp">boost/operators.hpp</a><br>
-      <a href="operators.htm">[Documentation]</a></td>
-    <td>Templates <b>equality_comparable</b>, <b>less_than_comparable</b>, <b>addable</b>,
-      and the like ease the task of defining comparison and arithmetic
-      operators, and iterators.</td>
-  </tr>
-  <tr>
-    <td><a href="../../boost/detail/type_traits.hpp">boost/type_traits.hpp</a><br>
-      [<a href="type_traits.htm">Documentation</a>]</td>
-    <td>Template classes that describe the fundamental properties of a type. [<a href="c++_type_traits.htm">DDJ
-      Article &quot;C++ type traits&quot;</a>]</td>
-  </tr>
-  <tr>
-    <td><a href="../../boost/detail/call_traits.hpp">boost/call_traits.hpp</a><br>
-      [<a href="call_traits.htm">Documentation</a>]</td>
-    <td>Template class call_traits&lt;T&gt;, that defines types used for passing
-      parameters to and from a proceedure.</td>
-  </tr>
-  <tr>
-    <td><a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a><br>
-      [<a href="compressed_pair.htm">Documentation</a>]</td>
-    <td>Template class compressed_pait&lt;T1, T2&gt; which pairs two values
-      using the empty member optimisation where appropriate.</td>
-  </tr>
-</table>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->27 July 2000<!--webbot bot="Timestamp" endspan i-checksum="18770" --></p>
-
-</body>
-
-</html>
--- a/indirect_iterator.htm
+++ b/indirect_iterator.htm
@@ -0,0 +1,443 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+
+<html>
+<head>
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+    <meta name="ProgId" content="FrontPage.Editor.Document">
+
+    <title>Indirect Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+	
+    <img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
+    "center" width="277" height="86"> 
+
+    <h1>Indirect Iterator Adaptor</h1>
+    Defined in header <a href=
+    "../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a> 
+
+    <p>The indirect iterator adaptor augments an iterator by applying an
+    <b>extra</b> dereference inside of <tt>operator*()</tt>. For example, this
+    iterator makes it possible to view a container of pointers or
+    smart-pointers (e.g. <tt>std::list&lt;boost::shared_ptr&lt;foo&gt;
+    &gt;</tt>) as if it were a container of the pointed-to type. The following
+    <b>pseudo-code</b> shows the basic idea of the indirect iterator:
+
+    <blockquote>
+<pre>
+// inside a hypothetical indirect_iterator class...
+typedef std::iterator_traits&lt;BaseIterator&gt;::value_type Pointer;
+typedef std::iterator_traits&lt;Pointer&gt;::reference reference;
+
+reference indirect_iterator::operator*() const {
+  return **this-&gt;base_iterator;
+}
+</pre>
+    </blockquote>
+
+    <h2>Synopsis</h2>
+
+    <blockquote>
+<pre>
+namespace boost {
+  template &lt;class BaseIterator,
+            class Value, class Reference, class Category, class Pointer&gt;
+  struct indirect_iterator_generator;
+  
+  template &lt;class BaseIterator,
+            class Value, class Reference, class ConstReference, 
+            class Category, class Pointer, class ConstPointer&gt;
+  struct indirect_iterator_pair_generator;
+
+  template &lt;class BaseIterator&gt;
+  typename indirect_iterator_generator&lt;BaseIterator&gt;::type
+  make_indirect_iterator(BaseIterator base)  
+}
+</pre>
+    </blockquote>
+    <hr>
+
+    <h2><a name="indirect_iterator_generator">The Indirect Iterator Type
+    Generator</a></h2>
+    The <tt>indirect_iterator_generator</tt> template is a <a href=
+    "../../more/generic_programming.html#type_generator">generator</a> of
+    indirect iterator types. The main template parameter for this class is the
+    <tt>BaseIterator</tt> type that is being wrapped. In most cases the type of
+    the elements being pointed to can be deduced using
+    <tt>std::iterator_traits</tt>, but in some situations the user may want to
+    override this type, so there are also template parameters that allow a user
+    to control the <tt>value_type</tt>, <tt>pointer</tt>, and
+    <tt>reference</tt> types of the resulting iterators. 
+
+    <blockquote>
+<pre>
+template &lt;class BaseIterator,
+          class Value, class Reference, class Pointer&gt;
+class indirect_iterator_generator
+{
+public:
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> type; // the resulting indirect iterator type 
+};
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    This example uses the <tt>indirect_iterator_generator</tt> to create
+    indirect iterators which dereference the pointers stored in the
+    <tt>pointers_to_chars</tt> array to access the <tt>char</tt>s in the
+    <tt>characters</tt> array. 
+
+    <blockquote>
+<pre>
+#include &lt;boost/config.hpp&gt;
+#include &lt;vector&gt;
+#include &lt;iostream&gt;
+#include &lt;iterator&gt;
+#include &lt;boost/iterator_adaptors.hpp&gt;
+
+int main(int, char*[])
+{
+  char characters[] = "abcdefg";
+  const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
+  char* pointers_to_chars[N];                        // at the end.
+  for (int i = 0; i &lt; N; ++i)
+    pointers_to_chars[i] = &amp;characters[i];
+  
+  boost::indirect_iterator_generator&lt;char**, char&gt;::type 
+    indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
+
+  std::copy(indirect_first, indirect_last, std::ostream_iterator&lt;char&gt;(std::cout, ","));
+  std::cout &lt;&lt; std::endl;
+  
+  // to be continued...
+</pre>
+    </blockquote>
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>BaseIterator</tt> 
+
+        <td>The iterator type being wrapped. The <tt>value_type</tt>
+        of the base iterator should itself be dereferenceable.  
+        The return type of the <tt>operator*</tt> for the
+        <tt>value_type</tt> should match the <tt>Reference</tt> type.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The <tt>value_type</tt> of the resulting iterator, unless const. If
+        Value is <tt>const X</tt>, a conforming compiler makes the
+        <tt>value_type</tt> <tt><i>non-</i>const X</tt><a href=
+        "iterator_adaptors.htm#1">[1]</a>. Note that if the default
+         is used for <tt>Value</tt>, then there must be a valid specialization
+         of <tt>iterator_traits</tt> for the value type of the base iterator.
+         <br>
+         <b>Default:</b> <tt>std::iterator_traits&lt;<br>
+         <20> std::iterator_traits&lt;BaseIterator&gt;::value_type
+        &gt;::value_type</tt><a href="#2">[2]</a> 
+
+      <tr>
+        <td><tt>Reference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator*()</tt>.<br>
+         <b>Default:</b> <tt>Value&amp;</tt> 
+
+      <tr>
+        <td><tt>Pointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> <tt>Value*</tt> 
+
+      <tr>
+        <td><tt>Category</tt> 
+        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseIterator&gt;::iterator_category</tt> 
+
+    </table>
+
+    <h3>Concept Model</h3>
+    The indirect iterator will model whichever <a href=
+    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator
+    concept category</a> is modeled by the base iterator. Thus, if the
+    base iterator is a model of <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+    Access Iterator</a> then so is the resulting indirect iterator. If
+    the base iterator models a more restrictive concept, the resulting
+    indirect iterator will model the same concept <a href="#3">[3]</a>.
+
+    <h3>Members</h3>
+    The indirect iterator type implements the member functions and operators
+    required of the <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> concept. In addition it has the following constructor: 
+<pre>
+explicit indirect_iterator_generator::type(const BaseIterator&amp; it)
+</pre>
+    <br>
+     <br>
+     
+    <hr>
+
+    <p>
+
+    <h2><a name="indirect_iterator_pair_generator">The Indirect Iterator Pair
+    Generator</a></h2>
+    Sometimes a pair of <tt>const</tt>/non-<tt>const</tt> pair of iterators is
+    needed, such as when implementing a container. The
+    <tt>indirect_iterator_pair_generator</tt> class makes it more convenient to
+    create this pair of iterator types. 
+
+    <blockquote>
+<pre>
+template &lt;class BaseIterator,
+          class Value, class Pointer, class Reference,
+          class ConstPointer, class ConstReference&gt;
+class indirect_iterator_pair_generator
+{
+public:
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> iterator;       // the mutable indirect iterator type 
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> const_iterator; // the immutable indirect iterator type 
+};
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+
+    <blockquote>
+<pre>
+  // continuing from the last example...
+
+  typedef boost::indirect_iterator_pair_generator&lt;char**,
+    char, char*, char&amp;, const char*, const char&amp;&gt; PairGen;
+
+  char mutable_characters[N];
+  char* pointers_to_mutable_chars[N];
+  for (int i = 0; i &lt; N; ++i)
+    pointers_to_mutable_chars[i] = &amp;mutable_characters[i];
+
+  PairGen::iterator mutable_indirect_first(pointers_to_mutable_chars),
+    mutable_indirect_last(pointers_to_mutable_chars + N);
+  PairGen::const_iterator const_indirect_first(pointers_to_chars),
+    const_indirect_last(pointers_to_chars + N);
+
+  std::transform(const_indirect_first, const_indirect_last,
+     mutable_indirect_first, std::bind1st(std::plus&lt;char&gt;(), 1));
+
+  std::copy(mutable_indirect_first, mutable_indirect_last,
+      std::ostream_iterator&lt;char&gt;(std::cout, ","));
+  std::cout &lt;&lt; std::endl;
+  // to be continued...
+</pre>
+    </blockquote>
+
+    <p>The output is:
+
+    <blockquote>
+<pre>
+b,c,d,e,f,g,h,
+</pre>
+    </blockquote>
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>BaseIterator</tt> 
+
+        <td>The iterator type being wrapped. The <tt>value_type</tt> of the
+        base iterator should itself be dereferenceable.
+        The return type of the <tt>operator*</tt> for the
+        <tt>value_type</tt> should match the <tt>Reference</tt> type.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The <tt>value_type</tt> of the resulting iterators.
+         If Value is <tt>const X</tt>, a conforming compiler makes the
+         <tt>value_type</tt> <tt><i>non-</i>const X</tt><a href=
+         "iterator_adaptors.htm#1">[1]</a>. Note that if the default
+         is used for <tt>Value</tt>, then there must be a valid
+         specialization of <tt>iterator_traits</tt> for the value type
+         of the base iterator.<br>
+
+         <b>Default:</b> <tt>std::iterator_traits&lt;<br>
+         <20> std::iterator_traits&lt;BaseIterator&gt;::value_type
+        &gt;::value_type</tt><a href="#2">[2]</a> 
+
+      <tr>
+        <td><tt>Reference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting <tt>iterator</tt>, and
+        in particular, the result type of its <tt>operator*()</tt>.<br>
+         <b>Default:</b> <tt>Value&amp;</tt> 
+
+      <tr>
+        <td><tt>Pointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting <tt>iterator</tt>, and
+        in particular, the result type of its <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> <tt>Value*</tt> 
+
+      <tr>
+        <td><tt>ConstReference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting
+        <tt>const_iterator</tt>, and in particular, the result type of its
+        <tt>operator*()</tt>.<br>
+         <b>Default:</b> <tt>const Value&amp;</tt> 
+
+      <tr>
+        <td><tt>ConstPointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting <tt>const_iterator</tt>,
+        and in particular, the result type of its <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> <tt>const Value*</tt> 
+
+      <tr>
+        <td><tt>Category</tt> 
+        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseIterator&gt;::iterator_category</tt> 
+    </table>
+
+    <h3>Concept Model</h3>
+
+    The indirect iterators will model whichever <a href=
+    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator
+    concept category</a> is modeled by the base iterator. Thus, if the
+    base iterator is a model of <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+    Access Iterator</a> then so are the resulting indirect
+    iterators. If the base iterator models a more restrictive concept,
+    the resulting indirect iterators will model the same concept <a
+    href="#3">[3]</a>.
+
+
+    <h3>Members</h3>
+    The resulting <tt>iterator</tt> and <tt>const_iterator</tt> types implement
+    the member functions and operators required of the <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> concept. In addition they support the following constructors: 
+
+    <blockquote>
+<pre>
+explicit indirect_iterator_pair_generator::iterator(const BaseIterator&amp; it)
+explicit indirect_iterator_pair_generator::const_iterator(const BaseIterator&amp; it)
+</pre>
+    </blockquote>
+    <br>
+     <br>
+     
+    <hr>
+
+    <p>
+
+    <h2><a name="make_indirect_iterator">The Indirect Iterator Object
+    Generator</a></h2>
+    The <tt>make_indirect_iterator()</tt> function provides a more convenient
+    way to create indirect iterator objects. The function saves the user the
+    trouble of explicitly writing out the iterator types. 
+
+    <blockquote>
+<pre>
+template &lt;class BaseIterator&gt;
+typename indirect_iterator_generator&lt;BaseIterator&gt;::type
+make_indirect_iterator(BaseIterator base)  
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    Here we again print the <tt>char</tt>s from the array <tt>characters</tt>
+    by accessing them through the array of pointers <tt>pointer_to_chars</tt>,
+    but this time we use the <tt>make_indirect_iterator()</tt> function which
+    saves us some typing. 
+
+    <blockquote>
+<pre>
+  // continuing from the last example...
+
+  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
+      boost::make_indirect_iterator(pointers_to_chars + N),
+      std::ostream_iterator&lt;char&gt;(std::cout, ","));
+  std::cout &lt;&lt; std::endl;
+
+  return 0;
+}
+</pre>
+    </blockquote>
+    The output is: 
+
+    <blockquote>
+<pre>
+a,b,c,d,e,f,g,
+</pre>
+    </blockquote>
+    <hr>
+
+    <h3>Notes</h3>
+
+    <p>
+
+    <p><a name="2">[2]</a> If your compiler does not support partial
+    specialization and the base iterator or its <tt>value_type</tt> is a
+    builtin pointer type, you will not be able to use the default for
+    <tt>Value</tt> and will need to specify this type explicitly.
+
+    <p><a name="3">[3]</a>There is a caveat to which concept the
+    indirect iterator can model.  If the return type of the
+    <tt>operator*</tt> for the base iterator's value type is not a
+    true reference, then strickly speaking, the indirect iterator can
+    not be a model of <a href=
+    "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+    Iterator</a> or any of the concepts that refine it. In this case
+    the <tt>Category</tt> for the indirect iterator should be
+    specified as <tt>std::input_iterator_tag</tt>. However, even in
+    this case, if the base iterator is a random access iterator, the
+    resulting indirect iterator will still satisfy most of the
+    requirements for <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+    Access Iterator</a>.
+    
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->28 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14390" -->
+
+
+    <p>&copy; Copyright Jeremy Siek and David Abrahams 2001. Permission to
+    copy, use, modify, sell and distribute this document is granted provided
+    this copyright notice appears in all copies. This document is provided "as
+    is" without express or implied warranty, and with no claim as to its
+    suitability for any purpose. 
+    <!--  LocalWords:  html charset alt gif hpp BaseIterator const namespace struct
+             -->
+     
+    <!--  LocalWords:  ConstPointer ConstReference typename iostream int abcdefg
+             -->
+     <!--  LocalWords:  sizeof  PairGen pre Jeremy Siek David Abrahams
+             -->
+
+
+</body>
+</html>
--- a/indirect_iterator_example.cpp
+++ b/indirect_iterator_example.cpp
@@ -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.
+
+#include <boost/config.hpp>
+#include <vector>
+#include <iostream>
+#include <iterator>
+#include <functional>
+#include <boost/iterator_adaptors.hpp>
+
+int main(int, char*[])
+{
+  char characters[] = "abcdefg";
+  const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
+  char* pointers_to_chars[N];                        // at the end.
+  for (int i = 0; i < N; ++i)
+    pointers_to_chars[i] = &characters[i];
+
+  // Example of using indirect_iterator_generator
+  
+  boost::indirect_iterator_generator<char**, char>::type 
+    indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
+
+  std::copy(indirect_first, indirect_last, std::ostream_iterator<char>(std::cout, ","));
+  std::cout << std::endl;
+  
+
+  // Example of using indirect_iterator_pair_generator
+
+  typedef boost::indirect_iterator_pair_generator<char**,
+    char, char*, char&, const char*, const char&> PairGen;
+
+  char mutable_characters[N];
+  char* pointers_to_mutable_chars[N];
+  for (int i = 0; i < N; ++i)
+    pointers_to_mutable_chars[i] = &mutable_characters[i];
+
+  PairGen::iterator mutable_indirect_first(pointers_to_mutable_chars),
+    mutable_indirect_last(pointers_to_mutable_chars + N);
+  PairGen::const_iterator const_indirect_first(pointers_to_chars),
+    const_indirect_last(pointers_to_chars + N);
+
+  std::transform(const_indirect_first, const_indirect_last,
+		 mutable_indirect_first, std::bind1st(std::plus<char>(), 1));
+
+  std::copy(mutable_indirect_first, mutable_indirect_last,
+	    std::ostream_iterator<char>(std::cout, ","));
+  std::cout << std::endl;
+
+  
+  // Example of using make_indirect_iterator()
+
+  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
+	    boost::make_indirect_iterator(pointers_to_chars + N),
+	    std::ostream_iterator<char>(std::cout, ","));
+  std::cout << std::endl;
+  
+  return 0;
+}
--- a/indirect_iterator_test.cpp
+++ b/indirect_iterator_test.cpp
@@ -0,0 +1,151 @@
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  Revision History
+//  08 Mar 2001   Jeremy Siek
+//       Moved test of indirect iterator into its own file. It to
+//       to be in iterator_adaptor_test.cpp.
+
+#include <boost/config.hpp>
+#include <iostream>
+#include <algorithm>
+
+#include <boost/iterator_adaptors.hpp>
+#include <boost/pending/iterator_tests.hpp>
+#include <boost/concept_archetype.hpp>
+#include <stdlib.h>
+#include <deque>
+#include <set>
+
+struct my_iterator_tag : public std::random_access_iterator_tag { };
+
+using boost::dummyT;
+
+typedef std::deque<int> storage;
+typedef std::deque<int*> pointer_deque;
+typedef std::set<storage::iterator> iterator_set;
+
+void more_indirect_iterator_tests()
+{
+// For some reason all heck breaks loose in the compiler under these conditions.
+#if !defined(BOOST_MSVC) || !defined(__STL_DEBUG)
+    storage store(1000);
+    std::generate(store.begin(), store.end(), rand);
+    
+    pointer_deque ptr_deque;
+    iterator_set iter_set;
+
+    for (storage::iterator p = store.begin(); p != store.end(); ++p)
+    {
+        ptr_deque.push_back(&*p);
+        iter_set.insert(p);
+    }
+
+    typedef boost::indirect_iterator_pair_generator<
+        pointer_deque::iterator
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , int
+#endif
+    > IndirectDeque;
+
+    IndirectDeque::iterator db(ptr_deque.begin());
+    IndirectDeque::iterator de(ptr_deque.end());
+    assert(static_cast<std::size_t>(de - db) == store.size());
+    assert(db + store.size() == de);
+    IndirectDeque::const_iterator dci(db);
+    assert(db == dci);
+    assert(dci == db);
+    assert(dci != de);
+    assert(dci < de);
+    assert(dci <= de);
+    assert(de >= dci);
+    assert(de > dci);
+    dci = de;
+    assert(dci == de);
+
+    boost::random_access_iterator_test(db + 1, store.size() - 1, boost::next(store.begin()));
+    
+    *db = 999;
+    assert(store.front() == 999);
+
+    // Borland C++ is getting very confused about the typedef's here
+
+    typedef boost::indirect_iterator_generator<
+        iterator_set::iterator
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , int
+#endif
+        >::type indirect_set_iterator;
+
+    typedef boost::indirect_iterator_generator<
+        iterator_set::iterator,
+        const int
+        >::type const_indirect_set_iterator;
+
+    indirect_set_iterator sb(iter_set.begin());
+    indirect_set_iterator se(iter_set.end());
+    const_indirect_set_iterator sci(iter_set.begin());
+    assert(sci == sb);
+    assert(sci != se);
+    sci = se;
+    assert(sci == se);
+    
+    *boost::prior(se) = 888;
+    assert(store.back() == 888);
+    assert(std::equal(sb, se, store.begin()));
+
+    boost::bidirectional_iterator_test(boost::next(sb), store[1], store[2]);
+    assert(std::equal(db, de, store.begin()));
+
+#endif    
+}
+
+int
+main()
+{
+  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+                     dummyT(3), dummyT(4), dummyT(5) };
+  const int N = sizeof(array)/sizeof(dummyT);
+
+  // Test indirect_iterator_generator
+  {
+    dummyT* ptr[N];
+    for (int k = 0; k < N; ++k)
+      ptr[k] = array + k;
+
+    typedef boost::indirect_iterator_generator<dummyT**
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
+      >::type indirect_iterator;
+
+    typedef boost::indirect_iterator_generator<dummyT**, const dummyT>::type const_indirect_iterator;
+
+    indirect_iterator i(ptr);
+    boost::random_access_iterator_test(i, N, array);
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_indirect_iterator(ptr), N, array);
+#endif
+    
+    // check operator->
+    assert((*i).m_x == i->foo());
+
+    const_indirect_iterator j(ptr);
+    boost::random_access_iterator_test(j, N, array);
+
+    dummyT*const* const_ptr = ptr;
+    
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_indirect_iterator(const_ptr), N, array);
+#endif
+    boost::const_nonconst_iterator_test(i, ++j);
+
+    more_indirect_iterator_tests();
+  }
+  std::cout << "test successful " << std::endl;
+  return 0;
+}
--- a/iter_adaptor_fail_expected1.cpp
+++ b/iter_adaptor_fail_expected1.cpp
@@ -0,0 +1,27 @@
+//  Test boost/pending/iterator_adaptors.hpp
+
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+// Revision History
+// 21 Jan 01 Initial version (Jeremy Siek)
+
+#include <boost/config.hpp>
+#include <list>
+#include <boost/pending/iterator_adaptors.hpp>
+
+int main()
+{
+  typedef boost::iterator_adaptor<std::list<int>::iterator,
+    boost::default_iterator_policies,
+    int,int&,int*,std::bidirectional_iterator_tag> adaptor_type;
+  
+  adaptor_type i;
+  i += 4;
+  return 0;
+}
--- a/iter_adaptor_fail_expected2.cpp
+++ b/iter_adaptor_fail_expected2.cpp
@@ -0,0 +1,28 @@
+//  Test boost/pending/iterator_adaptors.hpp
+
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+// Revision History
+// 21 Jan 01 Initial version (Jeremy Siek)
+
+#include <boost/config.hpp>
+#include <iostream>
+#include <iterator>
+#include <boost/pending/iterator_adaptors.hpp>
+
+int main()
+{
+  typedef boost::iterator_adaptor<std::istream_iterator<int>,
+    boost::default_iterator_policies,
+    int,int&,int*,std::input_iterator_tag> adaptor_type;
+  
+  adaptor_type iter;
+  --iter;
+  return 0;
+}
--- a/iter_traits_gen_test.cpp
+++ b/iter_traits_gen_test.cpp
@@ -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.
+
+// 8 Mar 2001   Jeremy Siek
+//     Initial checkin.
+
+#include <boost/iterator_adaptors.hpp>
+#include <boost/pending/iterator_tests.hpp>
+#include <boost/static_assert.hpp>
+
+class bar { };
+void foo(bar) { }
+
+int
+main()
+{
+  using boost::dummyT;
+  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+		     dummyT(3), dummyT(4), dummyT(5) };
+  typedef boost::iterator_adaptor<dummyT*, 
+    boost::default_iterator_policies, dummyT> my_iter;
+  my_iter mi(array);
+
+  {
+    typedef boost::iterator_adaptor<my_iter, boost::default_iterator_policies,
+      boost::iterator_traits_generator
+      ::reference<dummyT>
+      ::iterator_category<std::input_iterator_tag> > iter_type;
+
+    BOOST_STATIC_ASSERT((boost::is_same<iter_type::iterator_category*,
+       std::input_iterator_tag*>::value));
+
+    BOOST_STATIC_ASSERT(( ! boost::is_convertible<iter_type::iterator_category*,
+       std::forward_iterator_tag*>::value));
+
+    iter_type i(mi);
+    boost::input_iterator_test(i, dummyT(0), dummyT(1));
+  }
+  {
+    typedef boost::iterator_adaptor<dummyT*,
+      boost::default_iterator_policies,
+      boost::iterator_traits_generator
+        ::value_type<dummyT>
+        ::reference<const dummyT&>
+        ::pointer<const dummyT*> 
+        ::iterator_category<std::forward_iterator_tag>
+        ::difference_type<std::ptrdiff_t> > adaptor_type;
+
+    adaptor_type i(array);
+
+    boost::input_iterator_test(i, dummyT(0), dummyT(1));
+    int zero = 0;
+    if (zero) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+
+  return 0;
+}
--- a/iterator_adaptor_examples.cpp
+++ b/iterator_adaptor_examples.cpp
@@ -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,335 @@
+//  Test boost/iterator_adaptors.hpp
+
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  08 Mar 01 Moved indirect and transform tests to separate files.
+//            (Jeremy Siek)
+//  19 Feb 01 Take adavantage of improved iterator_traits to do more tests
+//            on MSVC. Hack around an MSVC-with-STLport internal compiler
+//            error. (David Abrahams)
+//  11 Feb 01 Added test of operator-> for forward and input iterators.
+//            (Jeremy Siek)
+//  11 Feb 01 Borland fixes (David Abrahams)
+//  10 Feb 01 Use new adaptors interface. (David Abrahams)
+//  10 Feb 01 Use new filter_ interface. (David Abrahams)
+//  09 Feb 01 Use new reverse_ and indirect_ interfaces. Replace
+//            BOOST_NO_STD_ITERATOR_TRAITS with
+//            BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION to prove we've
+//            normalized to core compiler capabilities (David Abrahams)
+//  08 Feb 01 Use Jeremy's new make_reverse_iterator form; add more
+//            comprehensive testing. Force-decay array function arguments to
+//            pointers.
+//  07 Feb 01 Added tests for the make_xxx_iterator() helper functions.
+//            (Jeremy Siek)
+//  07 Feb 01 Replaced use of xxx_pair_generator with xxx_generator where
+//            possible (which was all but the projection iterator).
+//            (Jeremy Siek)
+//  06 Feb 01 Removed now-defaulted template arguments where possible
+//            Updated names to correspond to new generator naming convention.
+//            Added a trivial test for make_transform_iterator().
+//            Gave traits for const iterators a mutable value_type, per std.
+//            Resurrected my original tests for indirect iterators.
+//            (David Abrahams)
+//  04 Feb 01 Fix for compilers without standard iterator_traits
+//            (David Abrahams)
+//  13 Jun 00 Added const version of the iterator tests (Jeremy Siek)
+//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
+
+#include <boost/config.hpp>
+#include <iostream>
+
+#include <algorithm>
+#include <functional>
+
+#include <boost/iterator_adaptors.hpp>
+#include <boost/pending/iterator_tests.hpp>
+#include <boost/pending/integer_range.hpp>
+#include <boost/concept_archetype.hpp>
+#include <stdlib.h>
+#include <vector>
+#include <deque>
+#include <set>
+
+struct my_iterator_tag : public std::random_access_iterator_tag { };
+
+using boost::dummyT;
+
+
+struct mult_functor {
+  typedef int result_type;
+  typedef int argument_type;
+  // Functors used with transform_iterator must be
+  // DefaultConstructible, as the transform_iterator must be
+  // DefaultConstructible to satisfy the requirements for
+  // TrivialIterator.
+  mult_functor() { }
+  mult_functor(int aa) : a(aa) { }
+  int operator()(int b) const { return a * b; }
+  int a;
+};
+
+template <class Pair>
+struct select1st_ 
+  : public std::unary_function<Pair, typename Pair::first_type>
+{
+  const typename Pair::first_type& operator()(const Pair& x) const {
+    return x.first;
+  }
+  typename Pair::first_type& operator()(Pair& x) const {
+    return x.first;
+  }
+};
+
+struct one_or_four {
+  bool operator()(dummyT x) const {
+    return x.foo() == 1 || x.foo() == 4;
+  }
+};
+
+typedef std::deque<int> storage;
+typedef std::deque<int*> pointer_deque;
+typedef std::set<storage::iterator> iterator_set;
+
+int
+main()
+{
+  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+                     dummyT(3), dummyT(4), dummyT(5) };
+  const int N = sizeof(array)/sizeof(dummyT);
+
+  // sanity check, if this doesn't pass the test is buggy
+  boost::random_access_iterator_test(array,N,array);
+
+  // Check that the policy concept checks and the default policy
+  // implementation match up.
+  boost::function_requires< 
+     boost::RandomAccessIteratorPoliciesConcept<
+       boost::default_iterator_policies, int*,
+       boost::iterator<std::random_access_iterator_tag, int, std::ptrdiff_t,
+                      int*, int&>
+      > >();
+
+  // Test the iterator_adaptor
+  {
+    boost::iterator_adaptor<dummyT*, boost::default_iterator_policies, dummyT> i(array);
+    boost::random_access_iterator_test(i, N, array);
+    
+    boost::iterator_adaptor<const dummyT*, boost::default_iterator_policies, const dummyT> j(array);
+    boost::random_access_iterator_test(j, N, array);
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+
+  // Test projection_iterator_pair_generator
+  {    
+    typedef std::pair<dummyT,dummyT> Pair;
+    Pair pair_array[N];
+    for (int k = 0; k < N; ++k)
+      pair_array[k].first = array[k];
+
+    typedef boost::projection_iterator_pair_generator<select1st_<Pair>,
+      Pair*, const Pair*
+      > Projection;
+    
+    Projection::iterator i(pair_array);
+    boost::random_access_iterator_test(i, N, array);
+
+    boost::random_access_iterator_test(boost::make_projection_iterator(pair_array, select1st_<Pair>()), N, array);    
+    boost::random_access_iterator_test(boost::make_projection_iterator< select1st_<Pair> >(pair_array), N, array);    
+
+    Projection::const_iterator j(pair_array);
+    boost::random_access_iterator_test(j, N, array);
+
+    boost::random_access_iterator_test(boost::make_const_projection_iterator(pair_array, select1st_<Pair>()), N, array);
+    boost::random_access_iterator_test(boost::make_const_projection_iterator<select1st_<Pair> >(pair_array), N, array);
+
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+
+  // Test reverse_iterator_generator
+  {
+    dummyT reversed[N];
+    std::copy(array, array + N, reversed);
+    std::reverse(reversed, reversed + N);
+    
+    typedef boost::reverse_iterator_generator<dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
+      >::type reverse_iterator;
+    
+    reverse_iterator i(reversed + N);
+    boost::random_access_iterator_test(i, N, array);
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+#endif
+
+    typedef boost::reverse_iterator_generator<const dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , const dummyT
+#endif
+      >::type const_reverse_iterator;
+    
+    const_reverse_iterator j(reversed + N);
+    boost::random_access_iterator_test(j, N, array);
+
+    const dummyT* const_reversed = reversed;
+    
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+#endif
+    
+    boost::const_nonconst_iterator_test(i, ++j);    
+  }
+
+  // Test reverse_iterator_generator again, with traits fully deducible on all platforms
+  {
+    std::deque<dummyT> reversed_container;
+    std::reverse_copy(array, array + N, std::back_inserter(reversed_container));
+    const std::deque<dummyT>::iterator reversed = reversed_container.begin();
+
+
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::iterator>::type reverse_iterator;
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::const_iterator, const dummyT>::type const_reverse_iterator;
+
+    // MSVC/STLport gives an INTERNAL COMPILER ERROR when any computation
+    // (e.g. "reversed + N") is used in the constructor below.
+    const std::deque<dummyT>::iterator finish = reversed_container.end();
+    reverse_iterator i(finish);
+    
+    boost::random_access_iterator_test(i, N, array);
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+
+    const_reverse_iterator j = reverse_iterator(finish);
+    boost::random_access_iterator_test(j, N, array);
+
+    const std::deque<dummyT>::const_iterator const_reversed = reversed;
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+    
+    // Many compilers' builtin deque iterators don't interoperate well, though
+    // STLport fixes that problem.
+#if defined(__SGI_STL_PORT) || !defined(__GNUC__) && !defined(__BORLANDC__) && !defined(BOOST_MSVC)
+    boost::const_nonconst_iterator_test(i, ++j);
+#endif
+  }
+  
+  // Test integer_range's iterators
+  {
+    int int_array[] = { 0, 1, 2, 3, 4, 5 };
+    boost::integer_range<int> r(0, 5);
+    boost::random_access_iterator_test(r.begin(), r.size(), int_array);
+  }
+
+  // Test filter iterator
+  {
+    // Using typedefs for filter_gen::type confused Borland terribly.
+    typedef boost::detail::non_bidirectional_category<dummyT*>::type category;
+    
+    typedef boost::filter_iterator_generator<one_or_four, dummyT*
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+        , dummyT
+#endif
+        >::type filter_iter;
+
+#if defined(__BORLANDC__)
+    // Borland is choking on accessing the policies_type explicitly
+    // from the filter_iter. 
+    boost::forward_iterator_test(make_filter_iterator(array, array+N, 
+						      one_or_four()),
+				 dummyT(1), dummyT(4));
+#else
+    filter_iter i(array, filter_iter::policies_type(one_or_four(), array + N));
+    boost::forward_iterator_test(i, dummyT(1), dummyT(4));
+#endif
+
+#if !defined(__BORLANDC__)
+    // 
+    enum { is_forward = boost::is_same<
+           filter_iter::iterator_category,
+           std::forward_iterator_tag>::value };
+    BOOST_STATIC_ASSERT(is_forward);
+#endif
+
+    // On compilers not supporting partial specialization, we can do more type
+    // deduction with deque iterators than with pointers... unless the library
+    // is broken ;-(
+#if !defined(BOOST_MSVC) || defined(__SGI_STL_PORT)
+    std::deque<dummyT> array2;
+    std::copy(array+0, array+N, std::back_inserter(array2));
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array2.begin(), array2.end(), one_or_four()),
+        dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array2.begin(), array2.end()),
+        dummyT(1), dummyT(4));
+#endif
+
+#if !defined(BOOST_MSVC) // This just freaks MSVC out completely
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(
+            boost::make_reverse_iterator(array2.end()),
+            boost::make_reverse_iterator(array2.begin())
+            ),
+        dummyT(4), dummyT(1));
+#endif
+    
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array+0, array+N, one_or_four()),
+        dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array, array + N),
+        dummyT(1), dummyT(4));
+
+#endif
+  }
+
+  // check operator-> with a forward iterator
+  {
+    boost::forward_iterator_archetype<dummyT> forward_iter;
+#if defined(__BORLANDC__)
+    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      dummyT, const dummyT&, const dummyT*, 
+      std::forward_iterator_tag, std::ptrdiff_t> adaptor_type;
+#else
+    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      boost::iterator_traits_generator
+        ::value_type<dummyT>
+        ::reference<const dummyT&>
+        ::pointer<const dummyT*> 
+        ::iterator_category<std::forward_iterator_tag>
+        ::difference_type<std::ptrdiff_t> > adaptor_type;
+#endif
+    adaptor_type i(forward_iter);
+    int zero = 0;
+    if (zero) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+  // check operator-> with an input iterator
+  {
+    boost::input_iterator_archetype<dummyT> input_iter;
+    typedef boost::iterator_adaptor<boost::input_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      dummyT, const dummyT&, const dummyT*, 
+      std::input_iterator_tag, std::ptrdiff_t> adaptor_type;
+    adaptor_type i(input_iter);
+    int zero = 0;
+    if (zero) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+  std::cout << "test successful " << std::endl;
+  return 0;
+}
--- a/iterator_adaptors.htm
+++ b/iterator_adaptors.htm
@@ -0,0 +1,863 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html>
+<head>
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+    <meta name="ProgId" content="FrontPage.Editor.Document">
+
+    <title>Boost Iterator Adaptor Library</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>Boost Iterator Adaptor Library</h1>
+
+    <h2>Introduction</h2>
+
+    <p>The Iterator Adaptor library allows you transform an arbitrary ``base''
+    type into a standard-conforming iterator with the behaviors you choose.
+    Doing so is especially easy if the ``base'' type is itself an iterator. The
+    library also supplies several example <a href=
+    "../../more/generic_programming.html#adaptors">adaptors</a> which apply
+    specific useful behaviors to arbitrary base iterators.
+
+    <h2>Table of Contents</h2>
+
+    <ul>
+      <li>
+        Header <tt><a href=
+        "../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a></tt>
+        
+
+        <ul>
+          <li>
+            Generalized Iterator Adaptor 
+
+            <ul>
+              <li>Class template <tt><a href=
+              "#iterator_adaptor">iterator_adaptor</a></tt>
+
+              <li><a href="#template_parameters">Template Parameters</a>
+
+              <li><a href="#named_template_parameters">Named Template Parameters</a>
+
+              <li><a href="#policies">The Policies Class</a>
+
+              <li><a href="#additional_members">Additional Class Members</a>
+
+              <li><a href="#example">Example</a>
+
+              <li>(<tt>const</tt>/non-<tt>const</tt>) <a href=
+              "#iterator_interactions">Iterator Interactions</a>
+
+              <li><a href="#challenge">Challenge</a>
+
+              <li><a href="#concept_model">Concept Model</a>
+
+              <li><a href="#declaration_synopsis">Declaration Synopsis</a>
+
+              <li><a href="#notes">Notes</a>
+            </ul>
+
+          <li>
+            <a name="specialized_adaptors">Specialized Iterator Adaptors</a> 
+
+            <ul>
+              <li><a href="indirect_iterator.htm">Indirect Iterator Adaptor</a>
+
+              <li><a href="reverse_iterator.htm">Reverse Iterator Adaptor</a>
+
+              <li><a href="transform_iterator.htm">Transform Iterator
+              Adaptor</a>
+
+              <li><a href="projection_iterator.htm">Projection Iterator
+              Adaptor</a>
+
+              <li><a href="filter_iterator.htm">Filter Iterator Adaptor</a>
+            </ul>
+        </ul>
+
+      <li>Header <tt><a href=
+      "../../boost/counting_iterator.hpp">boost/counting_iterator.hpp</a></tt><br>
+
+       <a href="counting_iterator.htm">Counting Iterator Adaptor</a>
+
+      <li>Header <tt><a href=
+      "../../boost/function_output_iterator.hpp">boost/function_output_iterator.hpp</a></tt><br>
+
+       <a href="function_output_iterator.htm">Function Output Iterator Adaptor</a>
+    </ul>
+
+    <p><b><a href="http://www.boost.org/people/dave_abrahams.htm">Dave
+    Abrahams</a></b> started the library, applying <a href=
+    "../../more/generic_programming.html#policy">policy class</a> technique and
+    handling const/non-const iterator interactions. He also contributed the
+    <tt><a href="indirect_iterator.htm">indirect_</a></tt> and <tt><a href=
+    "reverse_iterator.htm">reverse_</a></tt> iterator generators, and expanded
+    <tt><a href="counting_iterator.htm">counting_iterator_generator</a></tt> to
+    cover all incrementable types. He edited most of the documentation,
+    sometimes heavily.<br>
+     <b><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy
+    Siek</a></b> contributed the <a href="transform_iterator.htm">transform
+    iterator</a> adaptor, the integer-only version of <tt><a href=
+    "counting_iterator.htm">counting_iterator_generator</a></tt>, 
+    the <a href="function_output_iterator.htm">function output iterator</a> 
+    adaptor, and most of the documentation.<br>
+     <b><a href="http://www.boost.org/people/john_potter.htm">John
+    Potter</a></b> contributed the <tt><a href=
+    "projection_iterator.htm">projection_</a></tt> and <tt><a href=
+    "filter_iterator.htm">filter_</a></tt> iterator generators and made some
+    simplifications to the main <tt><a href=
+    "#iterator_adaptor">iterator_adaptor</a></tt> template.<br>
+
+
+    <h2><a name="iterator_adaptor">Class template</a>
+    <tt>iterator_adaptor</tt></h2>
+    Implementing standard conforming iterators is a non-trivial task. There are
+    some fine points such as the interactions between an iterator and its
+    corresponding const_iterator, and there are myriad operators that should be
+    implemented but are easily forgotten or mishandled, such as
+    <tt>operator-&gt;()</tt>. Using <tt>iterator_adaptor</tt>, you can easily
+    implement an iterator class, and even more easily extend and <a href=
+    "../../more/generic_programming.html#adaptors">adapt</a> existing iterator
+    types. Moreover, it is easy to make a pair of interoperable <tt>const</tt>
+    and <tt>non-const</tt> iterators. 
+
+    <p><tt>iterator_adaptor</tt> is declared like this:
+<pre>
+template &lt;class Base, class Policies, 
+    class ValueOrNamedParams = typename std::iterator_traits&lt;Base&gt;::value_type,
+    class ReferenceOrNamedParams = <i>...(see below)</i>,
+    class PointerOrNamedParams = <i>...(see below)</i>,
+    class CategoryOrNamedParams = typename std::iterator_traits&lt;Base&gt;::iterator_category,
+    class DistanceOrNamedParams = typename std::iterator_traits&lt;Base&gt;::difference_type&gt;
+struct iterator_adaptor;
+</pre>
+
+    <h3><a name="template_parameters">Template Parameters</a></h3>
+
+    <p>Although <tt>iterator_adaptor</tt> takes seven template parameters,
+    defaults have been carefully chosen to minimize the number of parameters
+    you must supply in most cases, especially if <tt>BaseType</tt> is an
+    iterator.
+
+    <table border="1" summary="iterator_adaptor template parameters">
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>BaseType</tt> 
+
+        <td>The type being wrapped.
+
+      <tr>
+        <td><tt>Policies</tt> 
+
+        <td>A <a href="../../more/generic_programming.html#policy">policy
+        class</a> that supplies core functionality to the resulting iterator. A
+        detailed description can be found <a href="#policies">below</a>.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The <tt>value_type</tt> of the resulting iterator, unless const. If
+        Value is <tt>const X</tt> the
+        <tt>value_type</tt> will be (<i>non-</i><tt>const</tt>) <tt>X</tt><a href=
+        "#1">[1]</a>.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseType&gt;::value_type</tt> <a href=
+        "#2">[2]</a>
+
+      <tr>
+        <td><tt>Reference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator*()</tt>.<br>
+         <b>Default:</b> If <tt>Value</tt> is supplied, <tt>Value&amp;</tt> is
+        used. Otherwise
+        <tt>std::iterator_traits&lt;BaseType&gt;::reference</tt> is used.
+
+      <tr>
+        <td><tt>Pointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
+        otherwise <tt>std::iterator_traits&lt;BaseType&gt;::pointer</tt>.
+
+      <tr>
+        <td><tt>Category</tt> 
+
+        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseType&gt;::iterator_category</tt> 
+
+      <tr>
+        <td><tt>Distance</tt> 
+
+        <td>The <tt>difference_type</tt> for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseType&gt;::difference_type</tt> 
+
+      <tr>
+         <td><tt>NamedParams</tt>
+
+         <td>A list of named template parameters generated using the
+            <a href="#iterator_traits_generator">
+            <tt>iterator_traits_generator</tt></a> class (see below).
+    </table>
+
+    <h3><a name="named_template_parameters">Named Template Parameters</a></h3>
+    
+    With seven template parameters, providing arguments for
+    <tt>iterator_adaptor</tt> in the correct order can be challenging.
+    Also, often times one would like to specify the sixth or seventh
+    template parameter, but use the defaults for the third through
+    fifth. As a solution to these problems we provide a mechanism for
+    naming the last five template parameters, and providing them in
+    any order through the <tt>iterator_traits_generator</tt> class.
+
+    <blockquote>
+<pre>
+<a name="iterator_traits_generator">class iterator_traits_generator</a>
+{
+public:
+  template &lt;class Value&gt;
+  struct value_type : public <i>recursive magic</i> { };
+
+  template &lt;class Reference&gt;
+  struct reference : public <i>recursive magic</i> { };
+
+  template &lt;class Pointer&gt;
+  struct pointer : public <i>recursive magic</i> { };
+
+  template &lt;class Distance&gt;
+  struct difference_type : public <i>recursive magic</i> { };
+
+  template &lt;class Category&gt;
+  struct iterator_category : public <i>recursive magic</i> { };
+};
+</pre>
+    </blockquote>
+
+    The <tt>iterator_traits_generator</tt> is used to create a list of
+    of template arguments. For example, suppose you want to set the
+    <tt>Reference</tt> and <tt>Category</tt> parameters, and use the
+    defaults for the rest. Then you can use the traits generator as
+    follows:
+
+    <blockquote>
+<pre>
+iterator_traits_generator::reference&lt;foo&gt;::category&lt;std::input_iterator_tag&gt;
+</pre>
+    </blockquote>
+
+    This generated type can then be passed into the <tt>iterator_adaptor</tt>
+    class to replace any of the last five parameters. If you use the traits
+    generator in the <i>i</i>th parameter position, then the parameters <i>i</i>
+    through 7 will use the types specified in the generator. For example, the
+    following adapts <tt>foo_iterator</tt> to create an <a href=
+    "http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a> with
+    <tt>reference</tt> type <tt>foo</tt>, and whose other traits are determined
+    according to the defaults described <a href="#template_parameters">above</a>.
+
+    <blockquote>
+<pre>
+iterator_adaptor&lt;foo_iterator, foo_policies,
+    iterator_traits_generator
+    ::reference&lt;foo&gt;
+    ::iterator_category&lt;std::input_iterator_tag&gt;
+&gt;
+</pre>
+    </blockquote>
+
+    
+    <h3><a name="policies">The Policies Class</a></h3>
+
+    <p>The main task in using <tt>iterator_adaptor</tt> is creating an
+    appropriate <tt>Policies</tt> class. The <tt>Policies</tt> class will become
+    the functional heart of the resulting iterator, supplying the core
+    operations that determine its behavior. The <tt>iterator_adaptor</tt>
+    template defines all of the operators required of a <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> by dispatching to a <tt>Policies</tt> object. Your
+    <tt>Policies</tt> class must implement a subset of the core iterator
+    operations below corresponding to the iterator categories you want it to
+    support.<br>
+    <br>
+    
+
+    <table border="1" summary="iterator_adaptor Policies operations">
+      <caption>
+        <b>Core Iterator Operations</b><br>
+        <tt>T</tt>: adapted iterator type; <tt>p</tt>: object of type T; <tt>n</tt>: <tt>T::size_type</tt>; <tt>x</tt>: <tt>T::difference_type</tt>; <tt>p1</tt>, <tt>p2</tt>: iterators
+      </caption>
+
+      <tr>
+        <th>Operation
+
+        <th>Effects
+
+        <th>Implements Operations
+
+        <th>Required for Iterator Categories
+
+      <tr>
+        <td><tt>dereference</tt> 
+
+        <td>returns an element of the iterator's <tt>reference</tt> type
+        
+        <td><tt>*p</tt>, <tt>p[n]</tt>
+
+        <td rowspan="3"><a href=
+        "http://www.sgi.com/tech/stl/InputIterator.html">Input</a>/ <a href=
+        "http://www.sgi.com/tech/stl/OutputIterator.html">Output</a>/ <a href=
+        "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward</a>/ <a
+        href=
+        "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional</a>/
+        <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+        Access</a> 
+
+      <tr>
+        <td><tt>equal</tt> 
+
+        <td>tests the iterator for equality
+
+        <td><tt>p1&nbsp;==&nbsp;p2</tt>, <tt>p1&nbsp;!=&nbsp;p2</tt>
+
+      <tr>
+        <td><tt>increment</tt> 
+
+        <td>increments the iterator
+
+        <td><tt>++p</tt>, <tt>p++</tt>
+
+      <tr>
+        <td><tt>decrement</tt> 
+
+        <td>decrements the iterator
+
+        <td><tt>--p</tt>, <tt>p--</tt>
+
+        <td><a href=
+        "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional</a>/
+        <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+        Access</a> 
+
+      <tr>
+        <td><tt>less</tt> 
+
+        <td>imposes a <a href=
+        "http://www.sgi.com/tech/stl/StrictWeakOrdering.html">Strict Weak
+        Ordering</a> relation on iterators
+
+        <td> 
+           <tt>p1&nbsp;&lt;&nbsp;p2</tt>,
+           <tt>p1&nbsp;&lt;=&nbsp;p2</tt>,
+           <tt>p1&nbsp;&gt;&nbsp;p2</tt>,
+           <tt>p1&nbsp;&gt;=&nbsp;p2</tt>
+
+        <td rowspan="3"><a href=
+        "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+        Access</a> 
+
+      <tr>
+        <td><tt>distance</tt> 
+
+        <td>measures the distance between iterators
+
+        <td><tt>p1 - p2</tt>
+
+      <tr>
+        <td><tt>advance</tt> 
+
+        <td>adds an integer offset to iterators
+
+        <td>
+<tt>p&nbsp;+&nbsp;x</tt>,
+<tt>x&nbsp;+&nbsp;p</tt>,
+<tt>p&nbsp;+=&nbsp;x</tt>,
+<tt>p&nbsp;-&nbsp;x</tt>,
+<tt>p&nbsp;-=&nbsp;x</tt>
+        
+    </table>
+
+    <p>The library also supplies a "trivial" policy class,
+    <tt>default_iterator_policies</tt>, which implements all seven of the core
+    operations in the usual way. If you wish to create an iterator adaptor that
+    only changes a few of the base type's behaviors, then you can derive your
+    new policy class from <tt>default_iterator_policies</tt> to avoid retyping
+    the usual behaviors. You should also look at
+    <tt>default_iterator_policies</tt> as the ``boilerplate'' for your own
+    policy classes, defining functions with the same interface. This is the
+    definition of <tt>default_iterator_policies</tt>:<br>
+    <br>
+
+    <blockquote>
+<pre>
+struct <a name="default_iterator_policies">default_iterator_policies</a>
+{
+  template &lt;class Reference, class BaseType&gt;
+  Reference dereference(type&lt;Reference&gt;, const BaseType&amp; x) const
+    { return *x; }
+
+  template &lt;class BaseType&gt;
+  static void increment(BaseType&amp; x)
+    { ++x; }
+
+  template &lt;class BaseType1, class BaseType2&gt;
+  bool equal(BaseType1&amp; x, BaseType2&amp; y) const
+    { return x == y; }
+
+  template &lt;class BaseType&gt;
+  static void decrement(BaseType&amp; x)
+    { --x; }
+
+  template &lt;class BaseType, class DifferenceType&gt;
+  static void advance(BaseType&amp; x, DifferenceType n)
+    { x += n; }
+
+  template &lt;class Difference, class BaseType1, class BaseType2&gt;
+  Difference distance(type&lt;Difference&gt;, BaseType1&amp; x, BaseType2&amp; y) const
+    { return y - x; }
+
+  template &lt;class BaseType1, class BaseType2&gt;
+  bool less(BaseType1&amp; x, BaseType2&amp; y) const
+    { return x &lt; y; }
+};
+</pre>
+    </blockquote>
+
+    <p>Template member functions are used throughout
+    <tt>default_iterator_policies</tt> so that it can be employed with a wide
+    range of iterators. If we had used concrete types above, we'd have tied the
+    usefulness of <tt>default_iterator_policies</tt> to a particular range of
+    adapted iterators. If you follow the same pattern with your
+    <tt>Policies</tt> classes, you can use them to generate more specialized
+    adaptors along the lines of <a href="#specialized_adaptors">those supplied by this library</a>.
+
+    <h3><a name="additional_members">Additional Members</a></h3>
+    In addition to all of the member functions required of a <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a>, the <tt>iterator_adaptor</tt> class template defines the
+    following members. <br>
+     <br>
+     
+
+    <table border="1" summary="additional iterator_adaptor members">
+      <tr>
+        <td><tt>explicit iterator_adaptor(const Base&amp;, const Policies&amp; =
+        Policies())</tt>
+         <br><br>
+         Construct an adapted iterator from a base object and a policies
+         object. As this constructor is <tt>explicit</tt>, it does not
+         provide for implicit conversions from the <tt>Base</tt> type to
+         the iterator adaptor.
+
+      <tr>
+        <td><tt>template &lt;class B, class V, class R, class P&gt;<br>
+         iterator_adaptor(const
+        iterator_adaptor&lt;B,Policies,V,R,P,Category,Distance&gt;&amp;)</tt>
+        <br><br>
+         This constructor allows for conversion from non-<tt>const</tt> to
+        constant adapted iterators. See <a href=
+        "#iterator_interactions">below</a> for more details.<br>
+         Requires: <tt>B</tt> is convertible to <tt>Base</tt>.
+
+      <tr>
+        <td><tt>base_type base() const;</tt>
+         <br><br>
+         Return a copy of the base object.
+    </table>
+
+    <h3><a name="example">Example</a></h3>
+
+    <p>It is often useful to automatically apply some function to the value
+    returned by dereferencing an iterator. The <a href=
+    "./transform_iterator.htm">transform iterator</a> makes it easy to create
+    an iterator adaptor which does just that. Here we will show how easy it is
+    to implement the transform iterator using the <tt>iterator_adaptor</tt>
+    template.
+
+    <p>We want to be able to adapt a range of iterators and functions, so the
+    policies class will have a template parameter for the function type and it
+    will have a data member of that type. We know that the function takes one
+    argument and that we'll need to be able to deduce the <tt>result_type</tt>
+    of the function so we can use it for the adapted iterator's
+    <tt>value_type</tt>. <a href=
+    "http://www.sgi.com/Technology/STL/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>
+    is the <a href="../../more/generic_programming.html#concept">Concept</a>
+    that fulfills those requirements.
+
+    <p>To implement a transform iterator we will only change one of the base
+    iterator's behaviors, so the <tt>transform_iterator_policies</tt> class can
+    inherit the rest from <tt>default_iterator_policies</tt>. We will define
+    the <tt>dereference()</tt> member function, which is used to implement
+    <tt>operator*()</tt> of the adapted iterator. The implementation will
+    dereference the base iterator and apply the function object. The
+    <tt>type&lt;Reference&gt;</tt> parameter is used to convey the appropriate
+    return type. The complete code for <tt>transform_iterator_policies</tt>
+    is:<br>
+    <br>
+
+
+    <blockquote>
+<pre>
+  template &lt;class AdaptableUnaryFunction&gt;
+  struct transform_iterator_policies : public default_iterator_policies
+  {
+    transform_iterator_policies() { }
+
+    transform_iterator_policies(const AdaptableUnaryFunction&amp; f)
+      : m_f(f) { }
+
+    template &lt;class Reference, class BaseIterator&gt;
+    Reference dereference(type&lt;Reference&gt;, const BaseIterator&amp; i) const
+      { return m_f(*i); }
+
+    AdaptableUnaryFunction m_f;
+  };
+</pre>
+    </blockquote>
+
+    <p>The next step is to use the <tt>iterator_adaptor</tt> template to
+    construct the transform iterator type. The nicest way to package the
+    construction of the transform iterator is to create a <a href=
+    "../../more/generic_programming.html#type_generator">type generator</a>.
+    The first template parameter to the generator will be the type of the
+    function object and the second will be the base iterator type. We use
+    <tt>iterator_adaptor</tt> to define the transform iterator type as a nested
+    <tt>typedef</tt> inside the <tt>transform_iterator_generator</tt> class.
+    Because the function may return by-value, we must limit the
+    <tt>iterator_category</tt> to <a href=
+    "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>, and
+    the iterator's <tt>reference</tt> type cannot be a true reference (the
+    standard allows this for input iterators), so in this case we can use few
+    of <tt>iterator_adaptor</tt>'s default template arguments.<br>
+    <br>
+
+
+    <blockquote>
+<pre>
+template &lt;class AdaptableUnaryFunction, class Iterator&gt;
+struct transform_iterator_generator
+{
+    typedef typename AdaptableUnaryFunction::result_type value_type;
+public:
+    typedef iterator_adaptor&lt;Iterator, 
+        transform_iterator_policies&lt;AdaptableUnaryFunction&gt;,
+        value_type, value_type, value_type*, std::input_iterator_tag&gt;
+      type;
+};
+</pre>
+    </blockquote>
+
+    <p>As a finishing touch, we will create an <a href=
+    "../../more/generic_programming.html#object_generator">object generator</a>
+    for the transform iterator. This is a function that makes it more
+    convenient to create a transform iterator.<br>
+    <br>
+
+
+    <blockquote>
+<pre>
+template &lt;class AdaptableUnaryFunction, class Iterator&gt;
+typename transform_iterator_generator&lt;AdaptableUnaryFunction,Iterator&gt;::type
+make_transform_iterator(Iterator base,
+                        const AdaptableUnaryFunction&amp; f = AdaptableUnaryFunction())
+{
+    typedef typename transform_iterator_generator&lt;AdaptableUnaryFunction,
+      Iterator&gt;::type result_t;
+    return result_t(base, f);
+}
+</pre>
+    </blockquote>
+
+    <p>Here is an example that shows how to use a transform iterator to iterate
+    through a range of numbers, multiplying each of them by 2 and printing the
+    result to standard output.<br>
+    <br>
+
+
+    <blockquote>
+<pre>
+#include &lt;functional&gt;
+#include &lt;algorithm&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 };
+  const int N = sizeof(x)/sizeof(int);
+  std::cout &lt;&lt; "multiplying the array by 2:" &lt;&lt; std::endl;
+  std::copy(boost::make_transform_iterator(x, std::bind1st(std::multiplies&lt;int&gt;(), 2)),
+      boost::make_transform_iterator(x + N, std::bind1st(std::multiplies&lt;int&gt;(), 2)),
+      std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+  return 0;
+}
+</pre>
+      This output is: 
+<pre>
+2 4 6 8 10 12 14 16
+</pre>
+    </blockquote>
+
+    <h3><a name="iterator_interactions">Iterator Interactions</a></h3>
+
+    <p>C++ allows <tt>const</tt> and non-<tt>const</tt> pointers to interact in
+    the following intuitive ways:
+
+    <ul>
+      <li>a non-<tt>const</tt> pointer to <tt>T</tt> can be implicitly
+      converted to a <tt>const</tt> pointer to <tt>T</tt>.
+
+      <li><tt>const</tt> and non-<tt>const</tt> pointers to <tt>T</tt> can be
+      freely mixed in comparison expressions.
+
+      <li><tt>const</tt> and non-<tt>const</tt> pointers to <tt>T</tt> can be
+      freely subtracted, in any order.
+    </ul>
+
+    Getting user-defined iterators to work together that way is nontrivial (see
+    <a href="reverse_iterator.htm#interactions">here</a> for an example of where
+    the C++ standard got it wrong), but <tt>iterator_adaptor</tt> can make it
+    easy. The rules are as follows:
+
+    <ul>
+      <li><a name="interoperable">Adapted iterators that share the same <tt>Policies</tt>,
+      <tt>Category</tt>, and <tt>Distance</tt> parameters are called
+      <i>interoperable</i>.</a>
+
+      <li>An adapted iterator can be implicitly converted to any other adapted
+      iterator with which it is interoperable, so long as the <tt>Base</tt>
+      type of the source iterator can be converted to the <tt>Base</tt> type of
+      the target iterator.
+
+      <li>Interoperable iterators can be freely mixed in comparison expressions
+      so long as the <tt>Policies</tt> class has <tt>equal</tt> (and, for
+      random access iterators, <tt>less</tt>) members that can accept both
+      <tt>Base</tt> types in either order.
+
+      <li>Interoperable iterators can be freely mixed in subtraction
+      expressions so long as the <tt>Policies</tt> class has a
+      <tt>distance</tt> member that can accept both <tt>Base</tt> types in
+      either order.
+    </ul>
+
+    <h4>Example</h4>
+    
+    <p>The <a href="projection_iterator.htm">Projection Iterator</a> adaptor is similar to the <a
+href="./transform_iterator.htm">transform iterator adaptor</a> in that
+its <tt>operator*()</tt> applies some function to the result of
+dereferencing the base iterator and then returns the result. The
+difference is that the function must return a reference to some
+existing object (for example, a data member within the
+<tt>value_type</tt> of the base iterator). 
+
+    <p>
+The <a
+    href="projection_iterator.htm#projection_iterator_pair_generator">projection_iterator_pair_generator</a> template
+    is a special two-<a href="../../more/generic_programming.html#type_generator">type generator</a> for mutable and constant versions of a
+    projection iterator. It is defined as follows:
+<blockquote>
+<pre>
+template &lt;class AdaptableUnaryFunction, class Iterator, class ConstIterator&gt;
+struct projection_iterator_pair_generator {
+    typedef typename AdaptableUnaryFunction::result_type value_type;
+    typedef projection_iterator_policies&lt;AdaptableUnaryFunction&gt; policies;
+public:
+    typedef iterator_adaptor&lt;Iterator,policies,value_type&gt; iterator;
+    typedef iterator_adaptor&lt;ConstIterator,policies,value_type,
+        const value_type&amp;,const value_type*&gt; const_iterator;
+};
+</pre>
+</blockquote>
+
+<p>It is assumed that the <tt>Iterator</tt> and <tt>ConstIterator</tt> arguments are corresponding mutable
+and constant iterators. <ul>
+<li>
+Clearly, then, the
+<tt>projection_iterator_pair_generator</tt>'s <tt>iterator</tt> and
+<tt>const_iterator</tt> are <a href="#interoperable">interoperable</a>, since
+they share the same <tt>Policies</tt> and since <tt>Category</tt> and
+<tt>Distance</tt> as supplied by <tt>std::iterator_traits</tt> through the
+<a href="#template_parameters">default template parameters</a> to
+<tt>iterator_adaptor</tt> should be the same.
+
+<li>Since <tt>Iterator</tt> can presumably be converted to
+<tt>ConstIterator</tt>, the projection <tt>iterator</tt> will be convertible to
+the projection <tt>const_iterator</tt>.
+
+<li> Since <tt>projection_iterator_policies</tt> implements only the
+<tt>dereference</tt> operation, and inherits all other behaviors from <tt><a
+href="#default_iterator_policies">default_iterator_policies</a></tt>, which has
+fully-templatized <tt>equal</tt>, <tt>less</tt>, and <tt>distance</tt>
+operations, the <tt>iterator</tt> and <tt>const_iterator</tt> can be freely
+mixed in comparison and subtraction expressions.
+
+</ul>
+
+    <h3><a name="challenge">Challenge</a></h3>
+
+    <p>There is an unlimited number of ways 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><a name="concept_model">Concept Model</a></h3>
+    Depending on the <tt>Base</tt> and <tt>Policies</tt> template parameters,
+    an <tt>iterator_adaptor</tt> can be a <a href=
+    "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>, <a
+    href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+    Iterator</a>, <a href=
+    "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional
+    Iterator</a>, or <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a>. 
+
+    <h3><a name="declaration_synopsis">Declaration Synopsis</a></h3>
+<pre>
+template &lt;class Base, class Policies, 
+    class Value = typename std::iterator_traits&lt;Base&gt;::value_type,
+    class Reference = <i>...(see below)</i>,
+    class Pointer = <i>...(see below)</i>,
+    class Category = typename std::iterator_traits&lt;Base&gt;::iterator_category,
+    class Distance = typename std::iterator_traits&lt;Base&gt;::difference_type
+         &gt;
+struct iterator_adaptor
+{
+    typedef Distance difference_type;
+    typedef typename boost::remove_const&lt;Value&gt;::type value_type;
+    typedef Pointer pointer;
+    typedef Reference reference;
+    typedef Category iterator_category;
+    typedef Base base_type;
+    typedef Policies policies_type;
+
+    iterator_adaptor();
+    explicit iterator_adaptor(const Base&amp;, const Policies&amp; = Policies());
+
+    base_type base() const;
+
+    template &lt;class B, class V, class R, class P&gt;
+    iterator_adaptor(
+        const iterator_adaptor&lt;B,Policies,V,R,P,Category,Distance&gt;&amp;);
+
+    reference operator*() const;
+    <i>operator_arrow_result_type</i> operator-&gt;() const; <a href=
+"#3">[3]</a>
+    <i>value_type</i> operator[](difference_type n) const; <a href="#3">[4]</a>
+
+    iterator_adaptor&amp; operator++();
+    iterator_adaptor&amp; operator++(int);
+    iterator_adaptor&amp; operator--();
+    iterator_adaptor&amp; operator--(int);
+
+    iterator_adaptor&amp; operator+=(difference_type n);
+    iterator_adaptor&amp; operator-=(difference_type n);
+
+    iterator_adaptor&amp; operator-(Distance x) const;
+};
+
+template &lt;class B, class P, class V, class R, class Ptr, 
+    class C, class D1, class D2&gt;
+iterator_adaptor&lt;B,P,V,R,Ptr,C,D1&gt;
+operator+(iterator_adaptor&lt;B,P,V,R,Ptr,C,D1&gt;, D2);
+
+template &lt;class B, class P, class V, class R, class Ptr,
+    class C, class D1, class D2&gt;
+iterator_adaptor&lt;B,P,V,R,P,C,D1&gt;
+operator+(D2, iterator_adaptor&lt;B,P,V,R,Ptr,C,D1&gt; p);
+
+template &lt;class B1, class B2, class P, class V1, class V2,
+    class R1, class R2, class P1, class P2, class C, class D&gt;
+Distance operator-(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;, 
+                   const iterator_adaptor&lt;B2,P,V2,R2,P2,C,D&gt;&amp;);
+
+template &lt;class B1, class B2, class P, class V1, class V2,
+    class R1, class R2, class P1, class P2, class C, class D&gt;
+bool operator==(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;, 
+                const iterator_adaptor&lt;B2,P,V2,R2,P2,C,D&gt;&amp;);
+
+// and similarly for operators !=, &lt;, &lt;=, &gt;=, &gt;
+</pre>
+
+    <h3><a name="notes">Notes</a></h3>
+
+    <p><a name="1">[1]</a> The standard specifies that the <tt>value_type</tt>
+    of <tt>const</tt> iterators to <tt>T</tt> (e.g. <tt>const T*</tt>) is
+    <tt><i>non-</i>const T</tt>, while the <tt>pointer</tt> and
+    <tt>reference</tt> types for all <a href=
+    "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterators</a> are
+    <tt>const T*</tt> and <tt>const T&amp;</tt>, respectively. Stripping the
+    <tt>const</tt>-ness of <tt>Value</tt> allows you to easily
+    make a <tt>const</tt> iterator adaptor by supplying a <tt>const</tt> type
+    for <tt>Value</tt>, and allowing the defaults for the <tt>Pointer</tt> and
+    <tt>Reference</tt> parameters to take effect. Although compilers that don't
+    support partial specialization won't strip <tt>const</tt> for you, having a
+    <tt>const value_type</tt> is often harmless in practice.
+
+    <p><a name="2">[2]</a> If your compiler does not support partial
+    specialization and the base iterator is a builtin pointer type, you
+    will not be able to use the default for <tt>Value</tt> and will have to
+    specify this type explicitly.
+
+    <p><a name="3">[3]</a> The result type for the <tt>operator-&gt;()</tt>
+    depends on the category and value type of the iterator and is somewhat
+    complicated to describe. But be assured, it works in a stardard conforming
+    fashion, providing access to members of the objects pointed to by the
+    iterator.
+
+    <p><a name="4">[4]</a> The result type of <tt>operator[]()</tt> is
+    <tt>value_type</tt> instead of <tt>reference</tt> as might be expected.
+    There are two reasons for this choice. First, the C++ standard only
+    requires that the return type of an arbitrary <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a>'s <tt>operator[]</tt>be ``convertible to T'' (Table 76), so
+    when adapting an arbitrary base iterator we may not have a reference to
+    return. Second, and more importantly, for certain kinds of iterators,
+    returning a reference could cause serious memory problems due to the
+    reference being bound to a temporary object whose lifetime ends inside of
+    the <tt>operator[]</tt>.
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->09 Mar 2001<!--webbot bot="Timestamp" endspan i-checksum="14894" -->
+
+
+    <p>&copy; Copyright Dave Abrahams and Jeremy Siek 2001. Permission to copy,
+    use, modify, sell and distribute this document is granted provided this
+    copyright notice appears in all copies. This document is provided "as is"
+    without express or implied warranty, and with no claim as to its
+    suitability for any purpose. 
+
+</body>
+
+    <!--  LocalWords:  HTML html charset alt gif abrahams htm const
+        incrementable david abrahams
+         -->
+     
+    <!--  LocalWords:  jeremy siek mishandled interoperable typename struct Iter iter src
+         -->
+     
+    <!--  LocalWords:  int bool ForwardIterator BidirectionalIterator BaseIterator
+         -->
+     
+    <!--  LocalWords:  RandomAccessIterator DifferenceType AdaptableUnaryFunction
+         -->
+     
+    <!--  LocalWords:  iostream hpp sizeof InputIterator constness ConstIterator
+         David Abrahams
+         -->
+</html>
+
--- a/iterator_traits_test.cpp
+++ b/iterator_traits_test.cpp
@@ -0,0 +1,210 @@
+//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  04 Mar 2001 Patches for Intel C++ (Dave Abrahams)
+//  19 Feb 2001 Take advantage of improved iterator_traits to do more tests
+//              on MSVC. Reordered some #ifdefs for coherency.
+//              (David Abrahams)
+//  13 Feb 2001 Test new VC6 workarounds (David Abrahams)
+//  11 Feb 2001 Final fixes for Borland (David Abrahams)
+//  11 Feb 2001 Some fixes for Borland get it closer on that compiler
+//              (David Abrahams)
+//  07 Feb 2001 More comprehensive testing; factored out static tests for
+//              better reuse (David Abrahams)
+//  21 Jan 2001 Quick fix to my_iterator, which wasn't returning a
+//              reference type from operator* (David Abrahams)
+//  19 Jan 2001 Initial version with iterator operators (David Abrahams)
+
+#include <boost/detail/iterator.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/operators.hpp>
+#include <boost/static_assert.hpp>
+#include <iterator>
+#include <vector>
+#include <list>
+#include <cassert>
+#include <iostream>
+
+// An iterator for which we can get traits.
+struct my_iterator1
+    : boost::forward_iterator_helper<my_iterator1, char, long, const char*, const char&>
+{
+    my_iterator1(const char* p) : m_p(p) {}
+    
+    bool operator==(const my_iterator1& rhs) const
+        { return this->m_p == rhs.m_p; }
+
+    my_iterator1& operator++() { ++this->m_p; return *this; }
+    const char& operator*() { return *m_p; }
+ private:
+    const char* m_p;
+};
+
+// Used to prove that we don't require std::iterator<> in the hierarchy under
+// MSVC6, and that we can compute all the traits for a standard-conforming UDT
+// iterator.
+struct my_iterator2
+    : boost::equality_comparable<my_iterator2
+    , boost::incrementable<my_iterator2
+    , boost::dereferenceable<my_iterator2,const char*> > >
+{
+    typedef char value_type;
+    typedef long difference_type;
+    typedef const char* pointer;
+    typedef const char& reference;
+    typedef std::forward_iterator_tag iterator_category;
+    
+    my_iterator2(const char* p) : m_p(p) {}
+    
+    bool operator==(const my_iterator2& rhs) const
+        { return this->m_p == rhs.m_p; }
+
+    my_iterator2& operator++() { ++this->m_p; return *this; }
+    const char& operator*() { return *m_p; }
+ private:
+    const char* m_p;
+};
+
+// Used to prove that we're not overly confused by the existence of
+// std::iterator<> in the hierarchy under MSVC6 - we should find that
+// boost::detail::iterator_traits<my_iterator3>::difference_type is int.
+struct my_iterator3 : my_iterator1
+{
+    typedef int difference_type;
+    my_iterator3(const char* p) : my_iterator1(p) {}
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct non_portable_tests
+{
+    // Unfortunately, the VC6 standard library doesn't supply these :(
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+        typename boost::detail::iterator_traits<Iterator>::pointer,
+        pointer
+        >::value));
+    
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+        typename boost::detail::iterator_traits<Iterator>::reference,
+        reference
+        >::value));
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct portable_tests
+{
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+        typename boost::detail::iterator_traits<Iterator>::difference_type,
+        difference_type
+        >::value));
+    
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+        typename boost::detail::iterator_traits<Iterator>::iterator_category,
+        category
+        >::value));
+};
+
+// Test iterator_traits
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct input_iterator_test
+    : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+{
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+        typename boost::detail::iterator_traits<Iterator>::value_type,
+        value_type
+        >::value));
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct non_pointer_test
+    : input_iterator_test<Iterator,value_type,difference_type,pointer,reference,category>
+      , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+{
+};
+
+template <class Iterator,
+    class value_type, class difference_type, class pointer, class reference, class category>
+struct maybe_pointer_test
+    : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+      , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+#endif
+{
+};
+
+input_iterator_test<std::istream_iterator<int>, int, std::ptrdiff_t, int*, int&, std::input_iterator_tag>
+        istream_iterator_test;
+
+// 
+#if defined(__BORLANDC__) && !defined(__SGI_STL_PORT)
+typedef ::std::char_traits<char>::off_type distance;
+non_pointer_test<std::ostream_iterator<int>,int,
+    distance,int*,int&,std::output_iterator_tag> ostream_iterator_test;
+#elif defined(BOOST_MSVC_STD_ITERATOR)
+non_pointer_test<std::ostream_iterator<int>,
+    int, void, void, void, std::output_iterator_tag>
+        ostream_iterator_test;
+#else
+non_pointer_test<std::ostream_iterator<int>,
+    void, void, void, void, std::output_iterator_tag>
+        ostream_iterator_test;
+#endif
+
+
+#ifdef __KCC
+  typedef long std_list_diff_type;
+#else
+  typedef std::ptrdiff_t std_list_diff_type;
+#endif
+non_pointer_test<std::list<int>::iterator, int, std_list_diff_type, int*, int&, std::bidirectional_iterator_tag>
+        list_iterator_test;
+
+maybe_pointer_test<std::vector<int>::iterator, int, std::ptrdiff_t, int*, int&, std::random_access_iterator_tag>
+        vector_iterator_test;
+
+maybe_pointer_test<int*, int, std::ptrdiff_t, int*, int&, std::random_access_iterator_tag>
+        int_pointer_test;
+
+non_pointer_test<my_iterator1, char, long, const char*, const char&, std::forward_iterator_tag>
+       my_iterator1_test;
+                    
+non_pointer_test<my_iterator2, char, long, const char*, const char&, std::forward_iterator_tag>
+       my_iterator2_test;
+                    
+non_pointer_test<my_iterator3, char, int, const char*, const char&, std::forward_iterator_tag>
+       my_iterator3_test;
+                    
+int main()
+{
+    char chars[100];
+    int ints[100];
+    
+    for (std::ptrdiff_t length = 3; length < 100; length += length / 3)
+    {
+        std::list<int> l(length);
+        assert(boost::detail::distance(l.begin(), l.end()) == length);
+        
+        std::vector<int> v(length);
+        assert(boost::detail::distance(v.begin(), v.end()) == length);
+
+        assert(boost::detail::distance(&ints[0], ints + length) == length);
+        assert(boost::detail::distance(my_iterator1(chars), my_iterator1(chars + length)) == length);
+        assert(boost::detail::distance(my_iterator2(chars), my_iterator2(chars + length)) == length);
+        assert(boost::detail::distance(my_iterator3(chars), my_iterator3(chars + length)) == length);
+    }
+    return 0;
+}
--- a/numeric_traits_test.cpp
+++ b/numeric_traits_test.cpp
@@ -0,0 +1,393 @@
+//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  11 Feb 2001 Fixes for Borland (David Abrahams)
+//  23 Jan 2001 Added test for wchar_t (David Abrahams)
+//  23 Jan 2001 Now statically selecting a test for signed numbers to avoid
+//              warnings with fancy compilers. Added commentary and
+//              additional dumping of traits data for tested types (David
+//              Abrahams).
+//  21 Jan 2001 Initial version (David Abrahams)
+
+#include <boost/detail/numeric_traits.hpp>
+#include <cassert>
+#include <boost/type_traits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/utility.hpp>
+#include <boost/lexical_cast.hpp>
+#include <climits>
+#include <typeinfo>
+#include <iostream>
+#include <string>
+#ifndef BOOST_NO_LIMITS
+# include <limits>
+#endif
+
+// A macro for declaring class compile-time constants.
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+# define DECLARE_CLASS_CONST(type, init) static const type init
+#else
+# define DECLARE_CLASS_CONST(type, init) enum { init }
+#endif
+
+// =================================================================================
+// template class complement_traits<Number> --
+//
+//    statically computes the max and min for 1s and 2s-complement binary
+//    numbers. This helps on platforms without <limits> support. It also shows
+//    an example of a recursive template that works with MSVC!
+//
+
+template <unsigned size> struct complement; // forward
+
+// The template complement, below, does all the real work, using "poor man's
+// partial specialization". We need complement_traits_aux<> so that MSVC doesn't
+// complain about undefined min/max as we're trying to recursively define them. 
+template <class Number, unsigned size>
+struct complement_traits_aux
+{
+    DECLARE_CLASS_CONST(Number, max = complement<size>::template traits<Number>::max);
+    DECLARE_CLASS_CONST(Number, min = complement<size>::template traits<Number>::min);
+};
+
+template <unsigned size>
+struct complement
+{
+    template <class Number>
+    struct traits
+    {
+     private:
+        // indirection through complement_traits_aux neccessary to keep MSVC happy
+        typedef complement_traits_aux<Number, size - 1> prev;
+     public:
+        DECLARE_CLASS_CONST(Number, max =
+                            Number(Number(prev::max) << CHAR_BIT)
+                            + Number(UCHAR_MAX));
+        
+        DECLARE_CLASS_CONST(Number, min = Number(Number(prev::min) << CHAR_BIT));
+    };
+};
+
+// Template class complement_base<> -- defines values for min and max for
+// complement<1>, at the deepest level of recursion. Uses "poor man's partial
+// specialization" again.
+template <bool is_signed> struct complement_base;
+
+template <> struct complement_base<false>
+{
+    template <class Number>
+    struct values
+    {
+        DECLARE_CLASS_CONST(Number, min = 0);
+        DECLARE_CLASS_CONST(Number, max = UCHAR_MAX);
+    };
+};
+
+template <> struct complement_base<true>
+{
+    template <class Number>
+    struct values
+    {
+        DECLARE_CLASS_CONST(Number, min = SCHAR_MIN);
+        DECLARE_CLASS_CONST(Number, max = SCHAR_MAX);
+    };
+};
+
+// Base specialization of complement, puts an end to the recursion.
+template <>
+struct complement<1>
+{
+    template <class Number>
+    struct traits
+    {
+        DECLARE_CLASS_CONST(bool, is_signed = boost::detail::is_signed<Number>::value);
+        DECLARE_CLASS_CONST(Number, min =
+                            complement_base<is_signed>::template values<Number>::min);
+        DECLARE_CLASS_CONST(Number, max =
+                            complement_base<is_signed>::template values<Number>::max);
+    };
+};
+
+// Now here's the "pretty" template you're intended to actually use.
+//   complement_traits<Number>::min, complement_traits<Number>::max are the
+//   minimum and maximum values of Number if Number is a built-in integer type.
+template <class Number>
+struct complement_traits
+{
+    DECLARE_CLASS_CONST(Number, max = (complement_traits_aux<Number, sizeof(Number)>::max));
+    DECLARE_CLASS_CONST(Number, min = (complement_traits_aux<Number, sizeof(Number)>::min));
+};
+
+// =================================================================================
+
+// Support for streaming various numeric types in exactly the format I want. I
+// needed this in addition to all the assertions so that I could see exactly
+// what was going on.
+//
+// Numbers go through a 2-stage conversion process (by default, though, no real
+// conversion).
+//
+template <class T> struct stream_as {
+    typedef T t1;
+    typedef T t2;
+};
+
+// char types first get converted to unsigned char, then to unsigned.
+template <> struct stream_as<char> {
+    typedef unsigned char t1;
+    typedef unsigned t2;
+};
+template <> struct stream_as<unsigned char> {
+    typedef unsigned char t1; typedef unsigned t2;
+};
+template <> struct stream_as<signed char>  {
+    typedef unsigned char t1; typedef unsigned t2;
+};
+
+#if defined(BOOST_MSVC) // No intmax streaming built-in
+
+// On this platform, __int64 and __uint64 get streamed as strings
+template <> struct stream_as<boost::uintmax_t> {
+    typedef std::string t1;
+    typedef std::string t2;
+};
+
+template <> struct stream_as<boost::intmax_t>  {
+    typedef std::string t1;
+    typedef std::string t2;
+};
+#endif
+
+// Standard promotion process for streaming
+template <class T> struct promote
+{
+    static typename stream_as<T>::t1 from(T x) {
+        typedef typename stream_as<T>::t1 t1;
+        return t1(x);
+    }
+};
+
+#if defined(BOOST_MSVC) // No intmax streaming built-in
+
+// On this platform, stream them as long/unsigned long if they fit.
+// Otherwise, write a string.
+template <> struct promote<boost::uintmax_t> {
+    std::string static from(const boost::uintmax_t x) {
+        if (x > ULONG_MAX)
+            return std::string("large unsigned value");
+        else
+            return boost::lexical_cast<std::string>((unsigned long)x);
+    }
+};
+template <> struct promote<boost::intmax_t> {
+    std::string static from(const boost::intmax_t x) {
+        if (x > boost::intmax_t(ULONG_MAX))
+            return std::string("large positive signed value");
+        else if (x >= 0)
+            return boost::lexical_cast<std::string>((unsigned long)x);
+        
+        if (x < boost::intmax_t(LONG_MIN))
+            return std::string("large negative signed value");
+        else
+            return boost::lexical_cast<std::string>((long)x);
+    }
+};
+#endif
+
+// This is the function which converts types to the form I want to stream them in.
+template <class T>
+typename stream_as<T>::t2 stream_number(T x)
+{
+    return promote<T>::from(x);
+}
+// =================================================================================
+
+//
+// Tests for built-in signed and unsigned types
+//
+
+// Tag types for selecting tests
+struct unsigned_tag {};
+struct signed_tag {};
+
+// Tests for unsigned numbers. The extra default Number parameter works around
+// an MSVC bug.
+template <class Number>
+void test_aux(unsigned_tag, Number* = 0)
+{
+    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
+    BOOST_STATIC_ASSERT(!boost::detail::is_signed<Number>::value);
+    BOOST_STATIC_ASSERT(
+        (sizeof(Number) < sizeof(boost::intmax_t))
+        | (boost::is_same<difference_type, boost::intmax_t>::value));
+
+    // Force casting to Number here to work around the fact that it's an enum on MSVC
+    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
+    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) == Number(0));
+    
+    const Number max = complement_traits<Number>::max;
+    const Number min = complement_traits<Number>::min;
+    
+    const Number test_max = (sizeof(Number) < sizeof(boost::intmax_t))
+        ? max
+        : max / 2 - 1;
+
+    std::cout << std::hex << "(unsigned) min = " << stream_number(min) << ", max = "
+              << stream_number(max) << "..." << std::flush;
+    std::cout << "difference_type = " << typeid(difference_type).name() << "..."
+              << std::flush;
+    
+    difference_type d1 = boost::detail::numeric_distance(Number(0), test_max);
+    difference_type d2 = boost::detail::numeric_distance(test_max, Number(0));
+    
+    std::cout << "0->" << stream_number(test_max) << "==" << std::dec << stream_number(d1) << "; "
+              << std::hex << stream_number(test_max) << "->0==" << std::dec << stream_number(d2) << "..." << std::flush;
+
+    assert(d1 == difference_type(test_max));
+    assert(d2 == -difference_type(test_max));
+}
+
+// Tests for signed numbers. The extra default Number parameter works around an
+// MSVC bug.
+struct out_of_range_tag {};
+struct in_range_tag {};
+
+// This test morsel gets executed for numbers whose difference will always be
+// representable in intmax_t
+template <class Number>
+void signed_test(in_range_tag, Number* = 0)
+{
+    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
+    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
+    const Number max = complement_traits<Number>::max;
+    const Number min = complement_traits<Number>::min;
+    
+    difference_type d1 = boost::detail::numeric_distance(min, max);
+    difference_type d2 = boost::detail::numeric_distance(max, min);
+
+    std::cout << stream_number(min) << "->" << stream_number(max) << "==";
+    std::cout << std::dec << stream_number(d1) << "; ";
+    std::cout << std::hex << stream_number(max) << "->" << stream_number(min)
+              << "==" << std::dec << stream_number(d2) << "..." << std::flush;
+    assert(d1 == difference_type(max) - difference_type(min));
+    assert(d2 == difference_type(min) - difference_type(max));
+}
+
+// This test morsel gets executed for numbers whose difference may exceed the
+// capacity of intmax_t.
+template <class Number>
+void signed_test(out_of_range_tag, Number* = 0)
+{
+    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
+    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
+    const Number max = complement_traits<Number>::max;
+    const Number min = complement_traits<Number>::min;
+
+    difference_type min_distance = complement_traits<difference_type>::min;
+    difference_type max_distance = complement_traits<difference_type>::max;
+
+    const Number n1 = Number(min + max_distance);
+    const Number n2 = Number(max + min_distance);
+    difference_type d1 = boost::detail::numeric_distance(min, n1);
+    difference_type d2 = boost::detail::numeric_distance(max, n2);
+
+    std::cout << stream_number(min) << "->" << stream_number(n1) << "==";
+    std::cout << std::dec << stream_number(d1) << "; ";
+    std::cout << std::hex << stream_number(max) << "->" << stream_number(n2)
+              << "==" << std::dec << stream_number(d2) << "..." << std::flush;
+    assert(d1 == max_distance);
+    assert(d2 == min_distance);
+}
+
+template <class Number>
+void test_aux(signed_tag, Number* = 0)
+{
+    typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
+    BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
+    BOOST_STATIC_ASSERT(
+        (sizeof(Number) < sizeof(boost::intmax_t))
+        | (boost::is_same<difference_type, Number>::value));
+
+    // Force casting to Number here to work around the fact that it's an enum on MSVC
+    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
+    BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) < Number(0));
+    
+    const Number max = complement_traits<Number>::max;
+    const Number min = complement_traits<Number>::min;
+    
+    std::cout << std::hex << "min = " << stream_number(min) << ", max = "
+              << stream_number(max) << "..." << std::flush;
+    std::cout << "difference_type = " << typeid(difference_type).name() << "..."
+              << std::flush;
+
+    typedef typename boost::detail::if_true<
+                          (sizeof(Number) < sizeof(boost::intmax_t))>
+                        ::template then<
+                          in_range_tag,
+                          out_of_range_tag
+                        >::type
+        range_tag;
+    signed_test<Number>(range_tag());
+}
+
+
+// Test for all numbers. The extra default Number parameter works around an MSVC
+// bug.
+template <class Number>
+void test(Number* = 0)
+{
+    std::cout << "testing " << typeid(Number).name() << ":\n"
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+              << "is_signed: " << (std::numeric_limits<Number>::is_signed ? "true\n" : "false\n")
+              << "is_bounded: " << (std::numeric_limits<Number>::is_bounded ? "true\n" : "false\n")
+              << "digits: " << std::numeric_limits<Number>::digits << "\n"
+#endif
+              << "..." << std::flush;
+
+    // factoring out difference_type for the assert below confused Borland :(
+    typedef boost::detail::is_signed<
+#ifndef BOOST_MSVC
+        typename
+#endif
+        boost::detail::numeric_traits<Number>::difference_type
+        > is_signed;
+    BOOST_STATIC_ASSERT(is_signed::value);
+
+    typedef typename boost::detail::if_true<
+        boost::detail::is_signed<Number>::value
+        >::template then<signed_tag, unsigned_tag>::type signedness;
+    
+    test_aux<Number>(signedness());
+    std::cout << "passed" << std::endl;
+}
+
+int main()
+{
+    test<char>();
+    test<unsigned char>();
+    test<signed char>();
+    test<wchar_t>();
+    test<short>();
+    test<unsigned short>();
+    test<int>();
+    test<unsigned int>();
+    test<long>();
+    test<unsigned long>();
+#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
+    test<long long>();
+    test<unsigned long long>();
+#elif defined(BOOST_MSVC)
+    // The problem of not having compile-time static class constants other than
+    // enums prevents this from working, since values get truncated.
+    // test<boost::uintmax_t>();
+    // test<boost::intmax_t>();
+#endif
+    return 0;
+}
--- a/operators.htm
+++ b/operators.htm
@@ -11,8 +11,8 @@

 <h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
 <a href="../../boost/operators.hpp">boost/operators.hpp</a></h1>
-<p>Header <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>
-supplies (in namespace boost) several sets of templates:</p>
+<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>
@@ -43,10 +43,10 @@ additional operators, such as operator&gt;, &lt;=, &gt;=, and +.&nbsp; <a href="
 forms</a> of the templates are also provided to allow interaction with other
 types.</p>
 <p><a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>
-started the library and contributed the arithmetic operators in <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>.<br>
+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="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>.<br>
+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>
@@ -60,7 +60,7 @@ x &gt;= y,</code> and <code>x &lt;= y</code>. Moreover, unless your class has
 really surprising behavior, some of these related operators can be defined in
 terms of others (e.g. <code>x &gt;= y <b>&lt;=&gt;</b> !(x &lt; y)</code>).
 Replicating this boilerplate for multiple classes is both tedious and
-error-prone. The <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>
+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">
@@ -585,8 +585,7 @@ complicated than the old one, we think it's worth it to make the library more
 useful in real world. Alexy Gurtovoy contributed the code which supports the new
 usage idiom while allowing the library remain backward-compatible.</p>
 <hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->03 Aug 2000<!--webbot bot="Timestamp" endspan i-checksum="14750" -->
-</p>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->28 Sep 2000<!--webbot bot="Timestamp" endspan i-checksum="14938" --></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
--- a/projection_iterator.htm
+++ b/projection_iterator.htm
@@ -0,0 +1,391 @@
+<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>Projection Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+align="center" width="277" height="86">
+
+<h1>Projection Iterator Adaptor</h1>
+
+Defined in header
+<a href="../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
+
+<p>
+The projection iterator adaptor is similar to the <a
+href="./transform_iterator.htm">transform iterator adaptor</a> in that
+its <tt>operator*()</tt> applies some function to the result of
+dereferencing the base iterator and then returns the result. The
+difference is that the function must return a reference to some
+existing object (for example, a data member within the
+<tt>value_type</tt> of the base iterator). The following
+<b>pseudo-code</b> gives the basic idea. The data member <tt>p</tt> is
+the function object.
+
+<pre>
+  reference projection_iterator::operator*() const {
+    return this->p(*this->base_iterator);
+  }
+</pre>
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+  struct projection_iterator_generator;
+  
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, 
+            class BaseIterator, class ConstBaseIterator&gt;
+  struct projection_iterator_pair_generator;
+
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+  typename projection_iterator_generator&lt;AdaptableUnaryFunction, BaseIterator&gt;::type
+  make_projection_iterator(BaseIterator base,
+			   const AdaptableUnaryFunction& p = AdaptableUnaryFunction())
+
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class ConstBaseIterator&gt;
+  typename projection_iterator_generator&lt;AdaptableUnaryFunction, ConstBaseIterator&gt;::type
+  make_const_projection_iterator(ConstBaseIterator base,
+                                 const AdaptableUnaryFunction& p = AdaptableUnaryFunction())  
+}
+</pre>
+
+<hr>
+
+<h2><a name="projection_iterator_generator">The Projection Iterator Type
+Generator</a></h2>
+
+The class <tt>projection_iterator_generator</tt> is a helper class
+whose purpose is to construct an projection iterator type.  The main
+template parameter for this class is the <a
+href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html"><tt>AdaptableUnaryFunction</tt></a>
+function object type and the <tt>BaseIterator</tt> type that is being
+wrapped.
+
+<pre>
+template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+class projection_iterator_generator
+{
+public:
+  typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt;</tt> type; // the resulting projection iterator type 
+};
+</pre>
+
+<h3>Example</h3>
+
+In the following example we have a list of personnel records. Each
+record has an employee's name and ID number. We want to be able to
+traverse through the list accessing either the name or the ID numbers
+of the employees using the projection iterator so we create the
+function object classes <tt>select_name</tt> and
+<tt>select_ID</tt>. We then use the
+<tt>projection_iterator_generator</tt> class to create a projection
+iterator and use it to print out the names of the employees.
+
+<pre>
+#include &lt;boost/config.hpp&gt;
+#include &lt;list&gt;
+#include &lt;iostream&gt;
+#include &lt;iterator&gt;
+#include &lt;algorithm&gt;
+#include &lt;string&gt;
+#include &lt;boost/iterator_adaptors.hpp&gt;
+
+struct personnel_record {
+  personnel_record(std::string n, int id) : m_name(n), m_ID(id) { }
+  std::string m_name;
+  int m_ID;
+};
+
+struct select_name {
+  typedef personnel_record argument_type;
+  typedef std::string result_type;
+  const std::string&amp; operator()(const personnel_record&amp; r) const {
+    return r.m_name;
+  }
+  std::string&amp; operator()(personnel_record&amp; r) const {
+    return r.m_name;
+  }
+};
+
+struct select_ID {
+  typedef personnel_record argument_type;
+  typedef int result_type;
+  const int&amp; operator()(const personnel_record&amp; r) const {
+    return r.m_ID;
+  }
+  int&amp; operator()(personnel_record&amp; r) const {
+    return r.m_ID;
+  }
+};
+
+int main(int, char*[])
+{
+  std::list&lt;personnel_record&gt; personnel_list;
+
+  personnel_list.push_back(personnel_record("Barney", 13423));
+  personnel_list.push_back(personnel_record("Fred", 12343));
+  personnel_list.push_back(personnel_record("Wilma", 62454));
+  personnel_list.push_back(personnel_record("Betty", 20490));
+
+  // Example of using projection_iterator_generator
+  // to print out the names in the personnel list.
+
+  boost::projection_iterator_generator&lt;select_name,
+    std::list&lt;personnel_record&gt;::iterator&gt;::type
+    personnel_first(personnel_list.begin()),
+    personnel_last(personnel_list.end());
+
+  std::copy(personnel_first, personnel_last,
+            std::ostream_iterator&lt;std::string&gt;(std::cout, "\n"));
+  std::cout &lt;&lt; std::endl;
+
+  // to be continued...
+</pre>
+The output for this part is:
+<pre>
+Barney
+Fred
+Wilma
+Betty
+</pre>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html"><tt>AdaptableUnaryFunction</tt></a></TD>
+<TD>The type of the function object. The <tt>argument_type</tt> of the
+function must match the value type of the base iterator. The function
+should return a reference to the function's <tt>result_type</tt>.
+The <tt>result_type</tt> will be the resulting iterator's <tt>value_type</tt>.
+</TD>
+</TD>
+
+<TR>
+<TD><tt>BaseIterator</tt></TD>
+<TD>The iterator type being wrapped.</TD>
+</TD>
+</TR>
+
+</Table>
+
+<h3>Model of</h3>
+
+If the base iterator is a model of <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> then so is the resulting projection iterator.  If
+the base iterator supports less functionality than this the resulting
+projection iterator will also support less functionality.
+
+<h3>Members</h3>
+
+The projection iterator type implements the member functions and
+operators required of the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> concept.
+In addition it has the following constructor:
+
+<pre>
+projection_iterator_generator::type(const BaseIterator&amp; it,
+                                    const AdaptableUnaryFunction&amp; p = AdaptableUnaryFunction())
+</pre>
+
+<p>
+<hr>
+<p>
+
+<h2><a name="projection_iterator_pair_generator">The Projection Iterator Pair
+Generator</a></h2>
+
+Sometimes a mutable/const pair of iterator types is needed, such as
+when implementing a container type. The
+<tt>projection_iterator_pair_generator</tt> class makes it more
+convenient to create this pair of iterator types.
+
+<pre>
+template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator, class ConstBaseIterator&gt;
+class projection_iterator_pair_generator
+{
+public:
+  typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt;</tt> iterator;       // the mutable projection iterator type 
+  typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt;</tt> const_iterator; // the immutable projection iterator type 
+};
+</pre>
+
+<h3>Example</h3>
+
+In this part of the example we use the
+<tt>projection_iterator_pair_generator</tt> to create a mutable/const
+pair of projection iterators that access the ID numbers of the
+personnel. We use the mutable iterator to re-index the ID numbers from
+zero. We then use the constant iterator to print the ID numbers out.
+
+<pre>
+  // continuing from the last example...
+
+  typedef boost::projection_iterator_pair_generator&lt;select_ID,
+    std::list&lt;personnel_record&gt;::iterator,
+    std::list&lt;personnel_record&gt;::const_iterator&gt; PairGen;
+
+  PairGen::iterator ID_first(personnel_list.begin()),
+    ID_last(personnel_list.end());
+
+  int new_id = 0;
+  while (ID_first != ID_last) {
+    *ID_first = new_id++;
+    ++ID_first;
+  }
+
+  PairGen::const_iterator const_ID_first(personnel_list.begin()),
+    const_ID_last(personnel_list.end());
+
+  std::copy(const_ID_first, const_ID_last,
+            std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+  std::cout &lt;&lt; std::endl;
+  
+  // to be continued...
+</pre&gt;
+The output is:
+<pre>
+0 1 2 3 
+</pre>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html"><tt>AdaptableUnaryFunction</tt></a></TD>
+<TD>The type of the function object. The <tt>argument_type</tt> of the
+function must match the value type of the base iterator. The function
+should return a true reference to the function's <tt>result_type</tt>.
+The <tt>result_type</tt> will be the resulting iterator's <tt>value_type</tt>.
+</TD>
+</TD>
+
+<TR>
+<TD><tt>BaseIterator</tt></TD>
+<TD>The mutable iterator type being wrapped.</TD>
+</TD>
+</TR>
+
+<TR>
+<TD><tt>ConstBaseIterator</tt></TD>
+<TD>The constant iterator type being wrapped.</TD>
+</TD>
+</TR>
+
+</Table>
+
+<h3>Model of</h3>
+
+If the base iterator types model the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> then so do the resulting projection iterator
+types.  If the base iterators support less functionality the
+resulting projection iterator types will also support less
+functionality.  The resulting <tt>iterator</tt> type is mutable, and
+the resulting <tt>const_iterator</tt> type is constant.
+
+<h3>Members</h3>
+
+The resulting <tt>iterator</tt> and <tt>const_iterator</tt> types
+implements the member functions and operators required of the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> concept.  In addition they support the following
+constructors:
+
+<pre>
+projection_iterator_pair_generator::iterator(const BaseIterator&amp; it,
+                                             const AdaptableUnaryFunction&amp; p = AdaptableUnaryFunction())</pre>
+
+<pre>
+projection_iterator_pair_generator::const_iterator(const BaseIterator&amp; it,
+                                                   const AdaptableUnaryFunction&amp; p = AdaptableUnaryFunction())
+</pre>
+
+<p>
+<hr>
+<p>
+
+<h2><a name="make_projection_iterator">The Projection Iterator Object Generators</a></h2>
+
+The <tt>make_projection_iterator()</tt> and
+<tt>make_const_projection_iterator()</tt> functions provide a more
+convenient way to create projection iterator objects. The functions
+save the user the trouble of explicitly writing out the iterator
+types.
+
+<pre>
+template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+typename projection_iterator_generator&lt;AdaptableUnaryFunction, BaseIterator&gt;::type
+make_projection_iterator(BaseIterator base,
+			 const AdaptableUnaryFunction& p = AdaptableUnaryFunction())  
+
+template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class ConstBaseIterator&gt;
+typename projection_iterator_generator&lt;AdaptableUnaryFunction, ConstBaseIterator&gt;::type
+make_const_projection_iterator(ConstBaseIterator base,
+			       const AdaptableUnaryFunction& p = AdaptableUnaryFunction())  
+</pre>
+
+
+<h3>Example</h3>
+
+In this part of the example, we again print out the names of the
+personnel, but this time we use the
+<tt>make_const_projection_iterator()</tt> function to save some typing.
+
+<pre>
+  // continuing from the last example...
+
+  std::copy
+    (boost::make_const_projection_iterator&lt;select_name&gt;(personnel_list.begin()),
+     boost::make_const_projection_iterator&lt;select_name&gt;(personnel_list.end()),
+     std::ostream_iterator<std::string>(std::cout, "\n"));
+
+  return 0;
+}
+</pre>
+The output is:
+<pre>
+Barney
+Fred
+Wilma
+Betty
+</pre>
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->28 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14390" --></p>
+<p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
+modify, sell and distribute this document is granted provided this copyright
+notice appears in all copies. This document is provided &quot;as is&quot;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>
+<!--  LocalWords:  html charset alt gif hpp BaseIterator const namespace struct
+ -->
+<!--  LocalWords:  ConstPointer ConstReference typename iostream int abcdefg
+ -->
+<!--  LocalWords:  sizeof  PairGen pre Siek htm AdaptableUnaryFunction
+ -->
+<!--  LocalWords:  ConstBaseIterator
+ -->
--- a/projection_iterator_example.cpp
+++ b/projection_iterator_example.cpp
@@ -0,0 +1,96 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+#include <boost/config.hpp>
+#include <list>
+#include <iostream>
+#include <iterator>
+#include <algorithm>
+#include <string>
+#include <boost/iterator_adaptors.hpp>
+
+struct personnel_record {
+  personnel_record(std::string n, int id) : m_name(n), m_ID(id) { }
+  std::string m_name;
+  int m_ID;
+};
+
+struct select_name {
+  typedef personnel_record argument_type;
+  typedef std::string result_type;
+  const std::string& operator()(const personnel_record& r) const {
+    return r.m_name;
+  }
+  std::string& operator()(personnel_record& r) const {
+    return r.m_name;
+  }
+};
+
+struct select_ID {
+  typedef personnel_record argument_type;
+  typedef int result_type;
+  const int& operator()(const personnel_record& r) const {
+    return r.m_ID;
+  }
+  int& operator()(personnel_record& r) const {
+    return r.m_ID;
+  }
+};
+
+int main(int, char*[])
+{
+  std::list<personnel_record> personnel_list;
+
+  personnel_list.push_back(personnel_record("Barney", 13423));
+  personnel_list.push_back(personnel_record("Fred", 12343));
+  personnel_list.push_back(personnel_record("Wilma", 62454));
+  personnel_list.push_back(personnel_record("Betty", 20490));
+
+  // Example of using projection_iterator_generator
+  // to print out the names in the personnel list.
+
+  boost::projection_iterator_generator<select_name,
+    std::list<personnel_record>::iterator>::type
+    personnel_first(personnel_list.begin()),
+    personnel_last(personnel_list.end());
+
+  std::copy(personnel_first, personnel_last,
+            std::ostream_iterator<std::string>(std::cout, "\n"));
+  std::cout << std::endl;
+  
+  // Example of using projection_iterator_pair_generator
+  // to assign new ID numbers to the personnel.
+  
+  typedef boost::projection_iterator_pair_generator<select_ID,
+    std::list<personnel_record>::iterator,
+    std::list<personnel_record>::const_iterator> PairGen;
+
+  PairGen::iterator ID_first(personnel_list.begin()),
+    ID_last(personnel_list.end());
+
+  int new_id = 0;
+  while (ID_first != ID_last) {
+    *ID_first = new_id++;
+    ++ID_first;
+  }
+
+  PairGen::const_iterator const_ID_first(personnel_list.begin()),
+    const_ID_last(personnel_list.end());
+
+  std::copy(const_ID_first, const_ID_last,
+            std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+  std::cout << std::endl;
+  
+  // Example of using make_const_projection_iterator()
+  // to print out the names in the personnel list again.
+  
+  std::copy
+    (boost::make_const_projection_iterator<select_name>(personnel_list.begin()),
+     boost::make_const_projection_iterator<select_name>(personnel_list.end()),
+     std::ostream_iterator<std::string>(std::cout, "\n"));
+
+  return 0;
+}
--- a/reverse_iterator.htm
+++ b/reverse_iterator.htm
@@ -0,0 +1,331 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+
+<html>
+<head>
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+    <meta name="ProgId" content="FrontPage.Editor.Document">
+
+    <title>Reverse Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+    <img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
+    "center" width="277" height="86"> 
+
+    <h1>Reverse Iterator Adaptor</h1>
+    Defined in header <a href=
+    "../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a> 
+
+    <p>The reverse iterator adaptor flips the direction of a base iterator's
+    motion. Invoking <tt>operator++()</tt> moves the base iterator backward and
+    invoking <tt>operator--()</tt> moves the base iterator forward. The Boost
+    reverse iterator adaptor is better to use than the
+    <tt>std::reverse_iterator</tt> class in situations where pairs of
+    mutable/constant iterators are needed (e.g., in containers) because
+    comparisons and conversions between the mutable and const versions are
+    implemented correctly.
+
+    <h2>Synopsis</h2>
+<pre>
+namespace boost {
+  template &lt;class <a href=
+"http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>,
+            class Value, class Reference, class Pointer, class Category, class Distance&gt;
+  struct reverse_iterator_generator;
+  
+  template &lt;class <a href=
+"http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>&gt;
+  typename reverse_iterator_generator&lt;BidirectionalIterator&gt;::type
+  make_reverse_iterator(BidirectionalIterator base)  
+}
+</pre>
+    <hr>
+
+    <h2><a name="reverse_iterator_generator">The Reverse Iterator Type
+    Generator</a></h2>
+    The <tt>reverse_iterator_generator</tt> template is a <a href=
+    "../../more/generic_programming.html#type_generator">generator</a> of
+    reverse iterator types. The main template parameter for this class is the
+    base <tt>BidirectionalIterator</tt> type that is being adapted. In most
+    cases the associated types of the base iterator can be deduced using
+    <tt>std::iterator_traits</tt>, but in some situations the user may want to
+    override these types, so there are also template parameters for the base
+    iterator's associated types. 
+
+    <blockquote>
+<pre>
+template &lt;class <a href=
+"http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>,
+          class Value, class Reference, class Pointer, class Category, class Distance&gt;
+class reverse_iterator_generator
+{
+public:
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> type; // the resulting reverse iterator type 
+};
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    In this example we sort a sequence of letters and then output the sequence
+    in descending order using reverse iterators. 
+
+    <blockquote>
+<pre>
+#include &lt;boost/config.hpp&gt;
+#include &lt;iostream&gt;
+#include &lt;algorithm&gt;
+#include &lt;boost/iterator_adaptors.hpp&gt;
+
+int main(int, char*[])
+{
+  char letters[] = "hello world!";
+  const int N = sizeof(letters)/sizeof(char) - 1;
+  std::cout &lt;&lt; "original sequence of letters:\t"
+      &lt;&lt; letters &lt;&lt; std::endl;
+
+  std::sort(letters, letters + N);
+
+  // Use reverse_iterator_generator to print a sequence
+  // of letters in reverse order.
+  
+  boost::reverse_iterator_generator&lt;char*&gt;::type
+    reverse_letters_first(letters + N),
+    reverse_letters_last(letters);
+
+  std::cout &lt;&lt; "letters in descending order:\t";
+  std::copy(reverse_letters_first, reverse_letters_last,
+      std::ostream_iterator&lt;char&gt;(std::cout));
+  std::cout &lt;&lt; std::endl;
+
+  // to be continued...
+</pre>
+    </blockquote>
+    The output is: 
+
+    <blockquote>
+<pre>
+original sequence of letters: hello world!
+letters in descending order:  wroolllhed! 
+</pre>
+    </blockquote>
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt><a href=
+        "http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a></tt>
+        
+
+        <td>The iterator type being wrapped.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The value-type of the base iterator and the resulting reverse
+        iterator.<br>
+         <b>Default:</b><tt>std::iterator_traits&lt;BidirectionalIterator&gt;::value_type</tt>
+        
+
+      <tr>
+        <td><tt>Reference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator*()</tt>.<br>
+         <b>Default:</b> If <tt>Value</tt> is supplied, <tt>Value&amp;</tt> is
+        used. Otherwise
+        <tt>std::iterator_traits&lt;BidirectionalIterator&gt;::reference</tt>
+        is used.
+
+      <tr>
+        <td><tt>Pointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
+        otherwise
+        <tt>std::iterator_traits&lt;BidirectionalIterator&gt;::pointer</tt>.
+
+      <tr>
+        <td><tt>Category</tt> 
+
+        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BidirectionalIterator&gt;::iterator_category</tt>
+        
+
+      <tr>
+        <td><tt>Distance</tt> 
+
+        <td>The <tt>difference_type</tt> for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BidirectionalIterator&amp;gt::difference_type</tt>
+        
+    </table>
+
+    <h3>Concept Model</h3>
+    The indirect iterator will model whichever <a href=
+    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator concept
+    category</a> is modeled by the base iterator. Thus, if the base iterator is
+    a model of <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> then so is the resulting indirect iterator. If the base
+    iterator models a more restrictive concept, the resulting indirect iterator
+    will model the same concept. The base iterator must be at least a <a href=
+    "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional
+    Iterator</a> 
+
+    <h3>Members</h3>
+    The reverse iterator type implements the member functions and operators
+    required of the <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> concept. In addition it has the following constructor: 
+
+    <blockquote>
+<pre>
+reverse_iterator_generator::type(const BidirectionalIterator&amp; it)
+</pre>
+    </blockquote>
+
+
+    <br>
+     <br>
+     
+    <hr>
+
+    <p>
+
+    <h2><a name="make_reverse_iterator">The Reverse Iterator Object
+    Generator</a></h2>
+    The <tt>make_reverse_iterator()</tt> function provides a more convenient
+    way to create reverse iterator objects. The function saves the user the
+    trouble of explicitly writing out the iterator types. 
+
+    <blockquote>
+<pre>
+template &lt;class BidirectionalIterator&gt;
+typename reverse_iterator_generator&lt;BidirectionalIterator&gt;::type
+make_reverse_iterator(BidirectionalIterator base);
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    In this part of the example we use <tt>make_reverse_iterator()</tt> to
+    print the sequence of letters in reverse-reverse order, which is the
+    original order. 
+
+    <blockquote>
+<pre>
+  // continuing from the previous example...
+
+  std::cout &lt;&lt; "letters in ascending order:\t";
+  std::copy(boost::make_reverse_iterator(reverse_letters_last),
+      boost::make_reverse_iterator(reverse_letters_first),
+      std::ostream_iterator&lt;char&gt;(std::cout));
+  std::cout &lt;&lt; std::endl;
+
+  return 0;
+}
+</pre>
+    </blockquote>
+    The output is: 
+
+    <blockquote>
+<pre>
+letters in ascending order:  !dehllloorw
+</pre>
+    </blockquote>
+    <hr>
+
+    <h2><a name="interactions">Constant/Mutable Iterator Interactions</a></h2>
+
+    <p>One failing of the standard <tt><a
+    href="http://www.sgi.com/tech/stl/ReverseIterator.html">reverse_iterator</a></tt>
+    adaptor is that it doesn't properly support interactions between adapted
+    <tt>const</tt> and non-<tt>const</tt> iterators. For example:
+<blockquote>
+<pre>
+#include &lt;vector&gt;
+
+template &lt;class T&gt; void convert(T x) {}
+
+// Test interactions of a matched pair of random access iterators
+template &lt;class Iterator, class ConstIterator&gt;
+void test_interactions(Iterator i, ConstIterator ci)
+{
+  bool eq = i == ci;               // comparisons
+  bool ne = i != ci;            
+  bool lt = i &lt; ci;
+  bool le = i &lt;= ci;
+  bool gt = i &gt; ci;
+  bool ge = i &gt;= ci;
+  std::size_t distance = i - ci;   // difference
+  ci = i;                          // assignment
+  ConstIterator ci2(i);            // construction
+  convert&lt;ConstIterator&gt;(i);       // implicit conversion
+}
+
+void f()
+{
+  typedef std::vector&lt;int&gt; vec;
+  vec v;
+  const vec&amp; cv;
+
+  test_interactions(v.begin(), cv.begin());   // <font color="#007F00">OK</font>
+  test_interactions(v.rbegin(), cv.rbegin()); // <font color="#FF0000">ERRORS ON EVERY TEST!!</font>
+</pre>
+</blockquote>
+Reverse iterators created with <tt>boost::reverse_iterator_generator</tt> don't have this problem, though:
+<blockquote>
+<pre>
+  typedef boost::reverse_iterator_generator&lt;vec::iterator&gt;::type ri;
+  typedef boost::reverse_iterator_generator&lt;vec::const_iterator&gt;::type cri;
+  test_interactions(ri(v.begin()), cri(cv.begin()));   // <font color="#007F00">OK!!</font>
+</pre>
+</blockquote>
+Or, more simply,
+<blockquote>
+<pre>
+  test_interactions(
+    boost::make_reverse_iterator(v.begin()), 
+    boost::make_reverse_iterator(cv.begin()));   // <font color="#007F00">OK!!</font>
+}
+</pre>
+</blockquote>
+
+<p>If you are wondering why there is no
+<tt>reverse_iterator_pair_generator</tt> in the manner of <tt><a
+href="projection_iterator.htm#projection_iterator_pair_generator">projection_iterator_pair_generator</a></tt>,
+the answer is simple: we tried it, but found that in practice it took
+<i>more</i> typing to use <tt>reverse_iterator_pair_generator</tt> than to
+simply use <tt>reverse_iterator_generator</tt> twice!<br><br>
+
+<hr>
+
+    
+    <p>Revised 
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->28 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14390" -->
+
+
+    <p>&copy; 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 "as is" without express or
+    implied warranty, and with no claim as to its suitability for any purpose. 
+    <!--  LocalWords:  html charset alt gif hpp BidirectionalIterator const namespace struct
+         -->
+     
+    <!--  LocalWords:  ConstPointer ConstReference typename iostream int abcdefg
+         -->
+     <!--  LocalWords:  sizeof  PairGen pre Siek wroolllhed dehllloorw
+         -->
+</body>
+</html>
+
--- a/reverse_iterator_example.cpp
+++ b/reverse_iterator_example.cpp
@@ -0,0 +1,42 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+#include <boost/config.hpp>
+#include <iostream>
+#include <algorithm>
+#include <boost/iterator_adaptors.hpp>
+
+int main(int, char*[])
+{
+  char letters[] = "hello world!";
+  const int N = sizeof(letters)/sizeof(char) - 1;
+  std::cout << "original sequence of letters:\t"
+	    << letters << std::endl;
+
+  std::sort(letters, letters + N);
+
+  // Use reverse_iterator_generator to print a sequence
+  // of letters in reverse order.
+  
+  boost::reverse_iterator_generator<char*>::type
+    reverse_letters_first(letters + N),
+    reverse_letters_last(letters);
+
+  std::cout << "letters in descending order:\t";
+  std::copy(reverse_letters_first, reverse_letters_last,
+	    std::ostream_iterator<char>(std::cout));
+  std::cout << std::endl;
+
+  // Use make_reverse_iterator() to print the sequence
+  // of letters in reverse-reverse order.
+
+  std::cout << "letters in ascending order:\t";
+  std::copy(boost::make_reverse_iterator(reverse_letters_last),
+	    boost::make_reverse_iterator(reverse_letters_first),
+	    std::ostream_iterator<char>(std::cout));
+  std::cout << std::endl;
+
+  return 0;
+}
--- a/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/transform_iterator.htm
+++ b/transform_iterator.htm
@@ -0,0 +1,215 @@
+<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>Transform Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+align="center" width="277" height="86">
+
+<h1>Transform Iterator Adaptor</h1>
+
+Defined in header
+<a href="../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
+
+<p>
+The transform iterator adaptor augments an iterator by applying some
+function object to the result of dereferencing the iterator. Another
+words, the <tt>operator*</tt> of the transform iterator first
+dereferences the base iterator, passes the result of this to the
+function object, and then returns the result. The following
+<b>pseudo-code</b> shows the basic idea:
+
+<pre>
+  value_type transform_iterator::operator*() const {
+    return this->f(*this->base_iterator);
+  }
+</pre>
+
+All of the other operators of the transform iterator behave in the
+same fashion as those of the base iterator.
+
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+  class transform_iterator_generator;
+
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+  typename transform_iterator_generator&lt;AdaptableUnaryFunction,Iterator&gt;::type
+  make_transform_iterator(BaseIterator base, const AdaptableUnaryFunction&amp; f = AdaptableUnaryFunction());
+}
+</pre>
+
+<hr>
+
+<h2><a name="transform_iterator_generator">The Transform Iterator Type
+Generator</a></h2>
+
+The class <tt>transform_iterator_generator</tt> is a helper class whose
+purpose is to construct a transform iterator type.  The template
+parameters for this class are the <tt>AdaptableUnaryFunction</tt> function object
+type and the <tt>BaseIterator</tt> type that is being wrapped.
+
+<pre>
+template &lt;class AdaptableUnaryFunction, class Iterator&gt;
+class transform_iterator_generator
+{
+public:
+    typedef <a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt; type;
+};
+</pre>
+
+<h3>Example</h3>
+
+<p>
+The following is an example of how to use the
+<tt>transform_iterator_generator</tt> class to iterate through a range of
+numbers, multiplying each of them by 2 when they are dereferenced.
+
+<p>
+<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_generator&lt;Function, int*&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;
+
+  // to be continued...
+</PRE>
+The output from this part is:
+<pre>
+2 4 6 8 10 12 14 16
+</pre>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html"><tt>AdaptableUnaryFunction</tt></a></TD>
+<TD>The function object that transforms each element in the iterator
+range.  The <tt>argument_type</tt> of the function object must match
+the value type of the base iterator.  The <tt>result_type</tt> of the
+function object will be the resulting iterator's
+<tt>value_type</tt>. If you want the resulting iterator to behave as
+an iterator, the result of the function should be solely a function of
+its argument.</TD>
+</TR>
+
+<TR>
+<TD><tt>BaseIterator</tt></TD>
+<TD>The iterator type being wrapped. This type must at least be a model
+ of the <a href="http://www.sgi.com/tech/stl/InputIterator">InputIterator</a> concept.</TD>
+</TR>
+
+</Table>
+
+<h3>Model of</h3>
+
+The transform iterator adaptor (the type
+<tt>transform_iterator_generator<...>::type</tt>) is a model of <a
+href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a><a href="#1">[1]</a>.
+
+
+<h3>Members</h3>
+
+The transform iterator type implements the member functions and
+operators required of the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
+concept, except that the <tt>reference</tt> type is the same as the <tt>value_type</tt>
+so <tt>operator*()</tt> returns by-value. In addition it has the following constructor:
+
+<pre>
+transform_iterator_generator::type(const BaseIterator&amp; it,
+                                   const AdaptableUnaryFunction&amp; f = AdaptableUnaryFunction())
+</pre>
+
+<p>
+<hr>
+<p>
+
+
+<h2><a name="make_transform_iterator">The Transform Iterator Object Generator</a></h2>
+
+<pre>
+template &lt;class AdaptableUnaryFunction, class BaseIterator&gt;
+typename transform_iterator_generator&lt;AdaptableUnaryFunction,BaseIterator&gt;::type
+make_transform_iterator(BaseIterator base,
+                        const AdaptableUnaryFunction&amp; f = AdaptableUnaryFunction());
+</pre>
+
+This function provides a convenient way to create transform iterators.
+
+<h3>Example</h3>
+
+Continuing from the previous example, we use the <tt>make_transform_iterator()</tt>
+function to add four to each element of the array.
+
+<pre>
+  std::cout << "adding 4 to each element in the array:" << std::endl;
+
+  std::copy(boost::make_transform_iterator(x, std::bind1st(std::plus<int>(), 4)),
+	    boost::make_transform_iterator(x + N, std::bind1st(std::plus<int>(), 4)),
+	    std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+  return 0;
+}
+</pre>
+The output from this part is:
+<pre>
+5 6 7 8 9 10 11 12
+</pre>
+
+<h3>Notes</h3>
+
+
+<a name="1">[1]</a> If the base iterator is a model of <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
+then the transform iterator will also suppport most of the
+functionality required by the Random Access Iterator concept. However, a
+transform iterator can never completely satisfy the requirements for
+<a
+href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>
+(or of any concepts that refine Forward Iterator, which includes
+Random Access Iterator and Bidirectional Iterator) since the <tt>operator*</tt> of the transform
+iterator always returns by-value.
+
+
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->09 Mar 2001<!--webbot bot="Timestamp" endspan i-checksum="14894" --></p>
+<p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
+modify, sell and distribute this document is granted provided this copyright
+notice appears in all copies. This document is provided &quot;as is&quot;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>
--- a/transform_iterator_example.cpp
+++ b/transform_iterator_example.cpp
@@ -0,0 +1,44 @@
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+
+
+#include <functional>
+#include <algorithm>
+#include <iostream>
+#include <boost/iterator_adaptors.hpp>
+
+int
+main(int, char*[])
+{
+  // This is a simple example of using the transform_iterators class to
+  // generate iterators that multiply the value returned by dereferencing
+  // the iterator. In this case we are multiplying by 2.
+  // Would be cooler to use lambda library in this example.
+
+  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+  const int N = sizeof(x)/sizeof(int);
+
+  typedef std::binder1st< std::multiplies<int> > Function;
+  typedef boost::transform_iterator_generator<Function, int*>::type doubling_iterator;
+
+  doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
+    i_end(x + N, 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;
+
+  std::cout << "adding 4 to each element in the array:" << std::endl;
+
+  std::copy(boost::make_transform_iterator(x, std::bind1st(std::plus<int>(), 4)),
+	    boost::make_transform_iterator(x + N, std::bind1st(std::plus<int>(), 4)),
+	    std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+  
+  return 0;
+}
+
+
--- a/transform_iterator_test.cpp
+++ b/transform_iterator_test.cpp
@@ -0,0 +1,54 @@
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  Revision History
+//  08 Mar 2001   Jeremy Siek
+//       Moved test of transform iterator into its own file. It to
+//       to be in iterator_adaptor_test.cpp.
+
+#include <boost/config.hpp>
+#include <iostream>
+#include <algorithm>
+#include <boost/iterator_adaptors.hpp>
+#include <boost/pending/iterator_tests.hpp>
+
+struct mult_functor {
+  typedef int result_type;
+  typedef int argument_type;
+  // Functors used with transform_iterator must be
+  // DefaultConstructible, as the transform_iterator must be
+  // DefaultConstructible to satisfy the requirements for
+  // TrivialIterator.
+  mult_functor() { }
+  mult_functor(int aa) : a(aa) { }
+  int operator()(int b) const { return a * b; }
+  int a;
+};
+
+int
+main()
+{
+  const int N = 10;
+
+  // Borland is getting confused about typedef's and constructors here
+
+  // 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_generator<mult_functor, int*>::type i(y, mult_functor(2));
+    boost::input_iterator_test(i, x[0], x[1]);
+    boost::input_iterator_test(boost::make_transform_iterator(&y[0], mult_functor(2)), x[0], x[1]);
+  }
+  std::cout << "test successful " << std::endl;
+  return 0;
+}
--- a/type_traits.htm
+++ b/type_traits.htm
@@ -1,626 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Type Traits</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<h1><img src="../../c++boost.gif" width="276" height="86">Header
-&lt;<a href="../../boost/detail/type_traits.hpp">boost/type_traits.hpp</a>&gt;</h1>
-
-<p>The contents of &lt;boost/type_traits.hpp&gt; are declared in
-namespace boost.</p>
-
-<p>The file &lt;<a href="../../boost/detail/type_traits.hpp">boost/type_traits.hpp</a>&gt;
-contains various template classes that describe the fundamental
-properties of a type; each class represents a single type
-property or a single type transformation. This documentation is
-divided up into the following sections:</p>
-
-<pre><a href="#fop">Fundamental type operations</a>
-<a href="#fp">Fundamental type properties</a>
-   <a href="#misc">Miscellaneous</a>
-<code>   </code><a href="#cv">cv-Qualifiers</a>
-<code>   </code><a href="#ft">Fundamental Types</a>
-<code>   </code><a href="#ct">Compound Types</a>
-<code>   </code><a href="#ot">Object/Scalar Types</a>
-<a href="#cs">Compiler Support Information</a>
-<a href="#ec">Example Code</a></pre>
-
-<h2><a name="fop"></a>Fundamental type operations</h2>
-
-<p>Usage: &quot;class_name&lt;T&gt;::type&quot; performs
-indicated transformation on type T.</p>
-
-<table border="1" cellpadding="7" cellspacing="1" width="100%">
-    <tr>
-        <td valign="top" width="45%"><p align="center">Expression.</p>
-        </td>
-        <td valign="top" width="45%"><p align="center">Description.</p>
-        </td>
-        <td valign="top" width="33%"><p align="center">Compiler.</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>remove_volatile&lt;T&gt;::type</code></td>
-        <td valign="top" width="45%">Creates a type the same as T
-        but with any top level volatile qualifier removed. For
-        example &quot;volatile int&quot; would become &quot;int&quot;.</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>remove_const&lt;T&gt;::type</code></td>
-        <td valign="top" width="45%">Creates a type the same as T
-        but with any top level const qualifier removed. For
-        example &quot;const int&quot; would become &quot;int&quot;.</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>remove_cv&lt;T&gt;::type</code></td>
-        <td valign="top" width="45%">Creates a type the same as T
-        but with any top level cv-qualifiers removed. For example
-        &quot;const int&quot; would become &quot;int&quot;, and
-        &quot;volatile double&quot; would become &quot;double&quot;.</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>remove_reference&lt;T&gt;::type</code></td>
-        <td valign="top" width="45%">If T is a reference type
-        then removes the reference, otherwise leaves T unchanged.
-        For example &quot;int&amp;&quot; becomes &quot;int&quot;
-        but &quot;int*&quot; remains unchanged.</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>add_reference&lt;T&gt;::type</code></td>
-        <td valign="top" width="45%">If T is a reference type
-        then leaves T unchanged, otherwise converts T to a
-        reference type. For example &quot;int&amp;&quot; remains
-        unchanged, but &quot;double&quot; becomes &quot;double&amp;&quot;.</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>remove_bounds&lt;T&gt;::type</code></td>
-        <td valign="top" width="45%">If T is an array type then
-        removes the top level array qualifier from T, otherwise
-        leaves T unchanged. For example &quot;int[2][3]&quot;
-        becomes &quot;int[3]&quot;.</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<h2><a name="fp"></a>Fundamental type properties</h2>
-
-<p>Usage: &quot;class_name&lt;T&gt;::value&quot; is true if
-indicated property is true, false otherwise. (Note that class_name&lt;T&gt;::value
-is always defined as a compile time constant).</p>
-
-<h3><a name="misc"></a>Miscellaneous</h3>
-
-<table border="1" cellspacing="1" width="100%">
-    <tr>
-        <td width="37%"><p align="center">Expression</p>
-        </td>
-        <td width="36%"><p align="center">Description</p>
-        </td>
-        <td width="27%"><p align="center">Compiler</p>
-        </td>
-    </tr>
-    <tr>
-        <td width="37%"><div align="center"><center><pre><code>is_same&lt;T,U&gt;::value</code></pre>
-        </center></div></td>
-        <td width="36%"><p align="center">True if T and U are the
-        same type.</p>
-        </td>
-        <td width="27%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td width="37%"><div align="center"><center><pre>is_convertible&lt;T,U&gt;::value</pre>
-        </center></div></td>
-        <td width="36%"><p align="center">True if type T is
-        convertible to type U.</p>
-        </td>
-        <td width="27%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="37%"><div align="center"><center><pre>alignment_of&lt;T&gt;::value</pre>
-        </center></div></td>
-        <td width="36%"><p align="center">An integral value
-        representing the minimum alignment requirements of type T
-        (strictly speaking defines a multiple of the type's
-        alignment requirement; for all compilers tested so far
-        however it does return the actual alignment).</p>
-        </td>
-        <td width="27%">&nbsp;</td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<h3><a name="cv"></a>cv-Qualifiers</h3>
-
-<p>The following classes determine what cv-qualifiers are present
-on a type (see 3.93).</p>
-
-<table border="1" cellpadding="7" cellspacing="1" width="100%">
-    <tr>
-        <td valign="top" width="37%"><p align="center">Expression.</p>
-        </td>
-        <td valign="top" width="37%"><p align="center">Description.</p>
-        </td>
-        <td valign="top" width="27%"><p align="center">Compiler.</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="37%"><code>is_const&lt;T&gt;::value</code></td>
-        <td valign="top" width="37%">True if type T is top-level
-        const qualified.</td>
-        <td valign="top" width="27%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="37%"><code>is_volatile&lt;T&gt;::value</code></td>
-        <td valign="top" width="37%">True if type T is top-level
-        volatile qualified.</td>
-        <td valign="top" width="27%"><p align="center">P</p>
-        </td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<h3><a name="ft"></a>Fundamental Types</h3>
-
-<p>The following will only ever be true for cv-unqualified types;
-these are closely based on the section 3.9 of the C++ Standard.</p>
-
-<table border="1" cellpadding="7" cellspacing="1" width="100%">
-    <tr>
-        <td valign="top" width="45%"><p align="center">Expression.</p>
-        </td>
-        <td valign="top" width="45%"><p align="center">Description.</p>
-        </td>
-        <td valign="top" width="33%"><p align="center">Compiler.</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_void&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True only if T is void.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_standard_unsigned_integral&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True only if T is one of the
-        standard unsigned integral types (3.9.1 p3) - unsigned
-        char, unsigned short, unsigned int, and unsigned long.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_standard_signed_integral&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True only if T is one of the
-        standard signed integral types (3.9.1 p2) - signed char,
-        short, int, and long.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_standard_integral&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a standard
-        integral type(3.9.1 p7) - T is either char, wchar_t, bool
-        or either is_standard_signed_integral&lt;T&gt;::value or
-        is_standard_integral&lt;T&gt;::value is true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_standard_float&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is one of the
-        standard floating point types(3.9.1 p8) - float, double
-        or long double.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_standard_arithmetic&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a standard
-        arithmetic type(3.9.1 p8) - implies is_standard_integral
-        or is_standard_float is true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_standard_fundamental&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a standard
-        arithmetic type or if T is void.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_extension_unsigned_integral&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True for compiler specific
-        unsigned integral types.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_extension_signed_integral&lt;T&gt;&gt;:value</code></td>
-        <td valign="top" width="45%">True for compiler specific
-        signed integral types.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_extension_integral&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if either is_extension_unsigned_integral&lt;T&gt;::value
-        or is_extension_signed_integral&lt;T&gt;::value is true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_extension_float&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True for compiler specific
-        floating point types.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_extension_arithmetic&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if either is_extension_integral&lt;T&gt;::value
-        or is_extension_float&lt;T&gt;::value are true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>&nbsp;is_extension_fundamental&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if either is_extension_arithmetic&lt;T&gt;::value
-        or is_void&lt;T&gt;::value are true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>&nbsp;is_unsigned_integral&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if either is_standard_unsigned_integral&lt;T&gt;::value
-        or is_extention_unsigned_integral&lt;T&gt;::value are
-        true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_signed_integral&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if either is_standard_signed_integral&lt;T&gt;::value
-        or is_extention_signed_integral&lt;T&gt;&gt;::value are
-        true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_integral&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if either is_standard_integral&lt;T&gt;::value
-        or is_extention_integral&lt;T&gt;::value are true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_float&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if either is_standard_float&lt;T&gt;::value
-        or is_extention_float&lt;T&gt;::value are true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_arithmetic&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if either is_integral&lt;T&gt;::value
-        or is_float&lt;T&gt;::value are true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_fundamental&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if either is_arithmetic&lt;T&gt;::value
-        or is_void&lt;T&gt;::value are true.</td>
-        <td valign="top" width="33%">&nbsp;</td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<h3><a name="ct"></a>Compound Types</h3>
-
-<p>The following will only ever be true for cv-unqualified types,
-as defined by the Standard.&nbsp;</p>
-
-<table border="1" cellpadding="7" cellspacing="1" width="100%">
-    <tr>
-        <td valign="top" width="45%"><p align="center">Expression</p>
-        </td>
-        <td valign="top" width="45%"><p align="center">Description</p>
-        </td>
-        <td valign="top" width="33%"><p align="center">Compiler</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_array&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is an array type.</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_pointer&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a regular
-        pointer type - including function pointers - but
-        excluding pointers to member functions (3.9.2 p1 and 8.3.1).</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_member_pointer&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a pointer to a
-        non-static class member (3.9.2 p1 and 8.3.1).</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_reference&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a reference
-        type (3.9.2 p1 and 8.3.2).</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_class&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a class or
-        struct type.</td>
-        <td valign="top" width="33%"><p align="center">PD</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_union&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a union type.</td>
-        <td valign="top" width="33%"><p align="center">C</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_enum&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is an enumerator
-        type.</td>
-        <td valign="top" width="33%"><p align="center">C</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_compound&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is any of the
-        above compound types.</td>
-        <td valign="top" width="33%"><p align="center">PD</p>
-        </td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<h3><a name="ot"></a>Object/Scalar Types</h3>
-
-<p>The following ignore any top level cv-qualifiers: if <code>class_name&lt;T&gt;::value</code>
-is true then <code>class_name&lt;cv-qualified-T&gt;::value</code>
-will also be true.</p>
-
-<table border="1" cellpadding="7" cellspacing="1" width="100%">
-    <tr>
-        <td valign="top" width="45%"><p align="center">Expression</p>
-        </td>
-        <td valign="top" width="45%"><p align="center">Description</p>
-        </td>
-        <td valign="top" width="33%"><p align="center">Compiler</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_object&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is not a reference
-        type, or a (possibly cv-qualified) void type.</td>
-        <td valign="top" width="33%"><p align="center">P</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_standard_scalar&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a standard
-        arithmetic type, an enumerated type, a pointer or a
-        member pointer.</td>
-        <td valign="top" width="33%"><p align="center">PD</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_extension_scalar&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is an extentions
-        arithmetic type, an enumerated type, a pointer or a
-        member pointer.</td>
-        <td valign="top" width="33%"><p align="center">PD</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_scalar&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is an arithmetic
-        type, an enumerated type, a pointer or a member pointer.</td>
-        <td valign="top" width="33%"><p align="center">PD</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_POD&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is a &quot;Plain
-        Old Data&quot; type (see 3.9 p2&amp;p3). Note that
-        although this requires compiler support to be correct in
-        all cases, if T is a scalar or an array of scalars then
-        we can correctly define T as a POD.</td>
-        <td valign="top" width="33%"><p align="center">PC</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>is_empty&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T is an empty struct
-        or class. If the compiler implements the &quot;zero sized
-        empty base classes&quot; optimisation, then is_empty will
-        correctly guess whether T is empty. Relies upon is_class
-        to determine whether T is a class type. Screens out enum
-        types by using is_convertible&lt;T,int&gt;, this means
-        that empty classes that overload operator int(), will not
-        be classified as empty.</td>
-        <td valign="top" width="33%"><p align="center">PCD</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>has_trivial_constructor&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T has a trivial
-        default constructor - that is T() is equivalent to memset.</td>
-        <td valign="top" width="33%"><p align="center">PC</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>has_trivial_copy&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T has a trivial copy
-        constructor - that is T(const T&amp;) is equivalent to
-        memcpy.</td>
-        <td valign="top" width="33%"><p align="center">PC</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>has_trivial_assign&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T has a trivial
-        assignment operator - that is if T::operator=(const T&amp;)
-        is equivalent to memcpy.</td>
-        <td valign="top" width="33%"><p align="center">PC</p>
-        </td>
-    </tr>
-    <tr>
-        <td valign="top" width="45%"><code>has_trivial_destructor&lt;T&gt;::value</code></td>
-        <td valign="top" width="45%">True if T has a trivial
-        destructor - that is if T::~T() has no effect.</td>
-        <td valign="top" width="33%"><p align="center">PC</p>
-        </td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<h2><a name="cs"></a>Compiler Support Information</h2>
-
-<p>The legends used in the tables above have the following
-meanings:</p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="480">
-    <tr>
-        <td valign="top" width="50%"><p align="center">P</p>
-        </td>
-        <td valign="top" width="90%">Denotes that the class
-        requires support for partial specialisation of class
-        templates to work correctly.</td>
-    </tr>
-    <tr>
-        <td valign="top" width="50%"><p align="center">C</p>
-        </td>
-        <td valign="top" width="90%">Denotes that direct compiler
-        support for that traits class is required.</td>
-    </tr>
-    <tr>
-        <td valign="top" width="50%"><p align="center">D</p>
-        </td>
-        <td valign="top" width="90%">Denotes that the traits
-        class is dependent upon a class that requires direct
-        compiler support.</td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<p>For those classes that are marked with a D or C, if compiler
-support is not provided, this type trait may return &quot;false&quot;
-when the correct value is actually &quot;true&quot;. The single
-exception to this rule is &quot;is_class&quot;, which attempts to
-guess whether or not T is really a class, and may return &quot;true&quot;
-when the correct value is actually &quot;false&quot;. This can
-happen if: T is a union, T is an enum, or T is a compiler-supplied
-scalar type that is not specialised for in these type traits.</p>
-
-<p><i>If there is no compiler support</i>, to ensure that these
-traits <i>always</i> return the correct values, specialise 'is_enum'
-for each user-defined enumeration type, 'is_union' for each user-defined
-union type, 'is_empty' for each user-defined empty composite type,
-and 'is_POD' for each user-defined POD type. The 'has_*' traits
-should also be specialized if the user-defined type has those
-traits and is <i>not</i> a POD.</p>
-
-<p>The following rules are automatically enforced:</p>
-
-<p>is_enum implies is_POD</p>
-
-<p>is_POD implies has_*</p>
-
-<p>This means, for example, if you have an empty POD-struct, just
-specialize is_empty and is_POD, which will cause all the has_* to
-also return true.</p>
-
-<h2><a name="ec"></a>Example code</h2>
-
-<p>Type-traits comes with two sample programs: <a
-href="type_traits_test.cpp">type_traits_test.cpp</a> tests the
-type traits classes - mostly this is a test of your compiler's
-support for the concepts used in the type traits implementation,
-while <a href="algo_opt_examples.cpp">algo_opt_examples.cpp</a>
-uses the type traits classes to &quot;optimise&quot; some
-familiar standard library algorithms.</p>
-
-<p>There are four algorithm examples in algo_opt_examples.cpp:</p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="638">
-    <tr>
-        <td valign="top" width="50%"><pre>opt::copy</pre>
-        </td>
-        <td valign="top" width="50%">If the copy operation can be
-        performed using memcpy then does so, otherwise uses a
-        regular element by element copy (<i>c.f.</i> std::copy).</td>
-    </tr>
-    <tr>
-        <td valign="top" width="50%"><pre>opt::fill</pre>
-        </td>
-        <td valign="top" width="50%">If the fill operation can be
-        performed by memset, then does so, otherwise uses a
-        regular element by element assign. Also uses call_traits
-        to optimise how the parameters can be passed (<i>c.f.</i>
-        std::fill).</td>
-    </tr>
-    <tr>
-        <td valign="top" width="50%"><pre>opt::destroy_array</pre>
-        </td>
-        <td valign="top" width="50%">If the type in the array has
-        a trivial destructor then does nothing, otherwise calls
-        destructors for all elements in the array - this
-        algorithm is the reverse of std::uninitialized_copy / std::uninitialized_fill.</td>
-    </tr>
-    <tr>
-        <td valign="top" width="50%"><pre>opt::iter_swap</pre>
-        </td>
-        <td valign="top" width="50%">Determines whether the
-        iterator is a proxy-iterator: if it is then does a &quot;slow
-        and safe&quot; swap, otherwise calls std::swap on the
-        assumption that std::swap may be specialised for the
-        iterated type.</td>
-    </tr>
-</table>
-
-<p>&nbsp;</p>
-
-<hr>
-
-<p>Revised 08<sup>th</sup> March 2000</p>
-
-<p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
-sell and distribute this document is granted provided this
-copyright notice appears in all copies. This document is provided
-&quot;as is&quot; without express or implied warranty, and with
-no claim as to its suitability for any purpose.</p>
-
-<p>Based on contributions by Steve Cleary, Beman Dawes, Howard
-Hinnant and John Maddock.</p>
-
-<p>Maintained by <a href="mailto:John_Maddock@compuserve.com">John
-Maddock</a>, the latest version of this file can be found at <a
-href="http://www.boost.org/">www.boost.org</a>, and the boost
-discussion list at <a href="http://www.egroups.com/list/boost">www.egroups.com/list/boost</a>.</p>
-</body>
-</html>
--- a/type_traits_test.cpp
+++ b/type_traits_test.cpp
@@ -1,595 +0,0 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & 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/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
-      Improved tests macros
-      Tidied up specialistions of type_types classes for test cases.
-*/
-
-#include <iostream>
-#include <typeinfo>
-
-#include <boost/type_traits.hpp>
-#include "type_traits_test.hpp"
-
-using namespace boost;
-
-// Since there is no compiler support, we should specialize:
-//  is_enum for all enumerations (is_enum implies is_POD)
-//  is_union for all unions
-//  is_empty for all empty composites
-//  is_POD for all PODs (except enums) (is_POD implies has_*)
-//  has_* for any UDT that has that trait and is not POD
-
-enum enum_UDT{ one, two, three };
-struct UDT
-{
-   UDT();
-   ~UDT();
-   UDT(const UDT&);
-   UDT& operator=(const UDT&);
-   int i;
-
-   void f1();
-   int f2();
-   int f3(int);
-   int f4(int, float);
-};
-
-struct POD_UDT { int x; };
-struct empty_UDT{ ~empty_UDT(){}; };
-struct empty_POD_UDT{};
-union union_UDT
-{
-  int x;
-  double y;
-  ~union_UDT();
-};
-union POD_union_UDT
-{
-  int x;
-  double y;
-};
-union empty_union_UDT
-{
-  ~empty_union_UDT();
-};
-union empty_POD_union_UDT{};
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-namespace boost {
-template <> struct is_enum<enum_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<POD_UDT>
-{ static const bool value = true; };
-// this type is not POD, so we have to specialize the has_* individually
-template <> struct has_trivial_constructor<empty_UDT>
-{ static const bool value = true; };
-template <> struct has_trivial_copy<empty_UDT>
-{ static const bool value = true; };
-template <> struct has_trivial_assign<empty_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<empty_POD_UDT>
-{ static const bool value = true; };
-template <> struct is_union<union_UDT>
-{ static const bool value = true; };
-template <> struct is_union<POD_union_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<POD_union_UDT>
-{ static const bool value = true; };
-template <> struct is_union<empty_union_UDT>
-{ static const bool value = true; };
-// this type is not POD, so we have to specialize the has_* individually
-template <> struct has_trivial_constructor<empty_union_UDT>
-{ static const bool value = true; };
-template <> struct has_trivial_copy<empty_union_UDT>
-{ static const bool value = true; };
-template <> struct has_trivial_assign<empty_union_UDT>
-{ static const bool value = true; };
-template <> struct is_union<empty_POD_union_UDT>
-{ static const bool value = true; };
-template <> struct is_POD<empty_POD_union_UDT>
-{ static const bool value = true; };
-}
-#else
-namespace boost {
-template <> struct is_enum<enum_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<POD_UDT>
-{ enum{ value = true }; };
-// this type is not POD, so we have to specialize the has_* individually
-template <> struct has_trivial_constructor<empty_UDT>
-{ enum{ value = true }; };
-template <> struct has_trivial_copy<empty_UDT>
-{ enum{ value = true }; };
-template <> struct has_trivial_assign<empty_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<empty_POD_UDT>
-{ enum{ value = true }; };
-template <> struct is_union<union_UDT>
-{ enum{ value = true }; };
-template <> struct is_union<POD_union_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<POD_union_UDT>
-{ enum{ value = true }; };
-template <> struct is_union<empty_union_UDT>
-{ enum{ value = true }; };
-// this type is not POD, so we have to specialize the has_* individually
-template <> struct has_trivial_constructor<empty_union_UDT>
-{ enum{ value = true }; };
-template <> struct has_trivial_copy<empty_union_UDT>
-{ enum{ value = true }; };
-template <> struct has_trivial_assign<empty_union_UDT>
-{ enum{ value = true }; };
-template <> struct is_union<empty_POD_union_UDT>
-{ enum{ value = true }; };
-template <> struct is_POD<empty_POD_union_UDT>
-{ enum{ value = true }; };
-}
-#endif
-
-class Base { };
-
-class Deriverd : public Base { };
-
-class NonDerived { };
-
-enum enum1
-{
-   one_,two_
-};
-
-enum enum2
-{
-   three_,four_
-};
-
-struct VB
-{
-   virtual ~VB(){};
-};
-
-struct VD : VB
-{
-   ~VD(){};
-};
-
-
-// Steve: All comments that I (Steve Cleary) have added below are prefixed with
-//  "Steve:"  The failures that BCB4 has on the tests are due to Borland's
-//  not considering cv-qual's as a part of the type -- they are considered
-//  compiler hints only.  These failures should be fixed before long.
-
-int main()
-{
-   std::cout << "Checking type operations..." << std::endl << std::endl;
-
-   // cv-qualifiers applied to reference types should have no effect
-   // declare these here for later use with is_reference and remove_reference:
-   typedef int& r_type;
-   typedef const r_type cr_type;
-
-   type_test(int, remove_reference<int>::type)
-   type_test(const int, remove_reference<const int>::type)
-   type_test(int, remove_reference<int&>::type)
-   type_test(const int, remove_reference<const int&>::type)
-   type_test(volatile int, remove_reference<volatile int&>::type)
-   type_test(int, remove_reference<cr_type>::type)
-
-   type_test(int, remove_const<const int>::type)
-   // Steve: fails on BCB4
-   type_test(volatile int, remove_const<volatile int>::type)
-   // Steve: fails on BCB4
-   type_test(volatile int, remove_const<const volatile int>::type)
-   type_test(int, remove_const<int>::type)
-   type_test(int*, remove_const<int* const>::type)
-   type_test(int, remove_volatile<volatile int>::type)
-   // Steve: fails on BCB4
-   type_test(const int, remove_volatile<const int>::type)
-   // Steve: fails on BCB4
-   type_test(const int, remove_volatile<const volatile int>::type)
-   type_test(int, remove_volatile<int>::type)
-   type_test(int*, remove_volatile<int* volatile>::type)
-   type_test(int, remove_cv<volatile int>::type)
-   type_test(int, remove_cv<const int>::type)
-   type_test(int, remove_cv<const volatile int>::type)
-   type_test(int, remove_cv<int>::type)
-   type_test(int*, remove_cv<int* volatile>::type)
-   type_test(int*, remove_cv<int* const>::type)
-   type_test(int*, remove_cv<int* const volatile>::type)
-   type_test(const int *, remove_cv<const int * const>::type)
-   type_test(int, remove_bounds<int>::type)
-   type_test(int*, remove_bounds<int*>::type)
-   type_test(int, remove_bounds<int[3]>::type)
-   type_test(int[3], remove_bounds<int[2][3]>::type)
-
-   std::cout << std::endl << "Checking type properties..." << std::endl << std::endl;
-
-   value_test(true, (is_same<int, int>::value))
-   value_test(false, (is_same<int, const int>::value))
-   value_test(false, (is_same<int, int&>::value))
-   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_const<int>::value)
-   value_test(true, is_const<const int>::value)
-   value_test(false, is_const<volatile int>::value)
-   value_test(true, is_const<const volatile int>::value)
-
-   value_test(false, is_volatile<int>::value)
-   value_test(false, is_volatile<const int>::value)
-   value_test(true, is_volatile<volatile int>::value)
-   value_test(true, is_volatile<const volatile int>::value)
-
-   value_test(true, is_void<void>::value)
-   // Steve: fails on BCB4
-   // JM: but looks as though it should according to [3.9.3p1]?
-   //value_test(false, is_void<const void>::value)
-   value_test(false, is_void<int>::value)
-
-   value_test(false, is_standard_unsigned_integral<UDT>::value)
-   value_test(false, is_standard_unsigned_integral<void>::value)
-   value_test(false, is_standard_unsigned_integral<bool>::value)
-   value_test(false, is_standard_unsigned_integral<char>::value)
-   value_test(false, is_standard_unsigned_integral<signed char>::value)
-   value_test(true, is_standard_unsigned_integral<unsigned char>::value)
-   value_test(false, is_standard_unsigned_integral<wchar_t>::value)
-   value_test(false, is_standard_unsigned_integral<short>::value)
-   value_test(true, is_standard_unsigned_integral<unsigned short>::value)
-   value_test(false, is_standard_unsigned_integral<int>::value)
-   value_test(true, is_standard_unsigned_integral<unsigned int>::value)
-   value_test(false, is_standard_unsigned_integral<long>::value)
-   value_test(true, is_standard_unsigned_integral<unsigned long>::value)
-   value_test(false, is_standard_unsigned_integral<float>::value)
-   value_test(false, is_standard_unsigned_integral<double>::value)
-   value_test(false, is_standard_unsigned_integral<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(false, is_standard_unsigned_integral<long long>::value)
-   value_test(false, is_standard_unsigned_integral<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(false, is_standard_unsigned_integral<__int64>::value)
-   value_test(false, is_standard_unsigned_integral<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_standard_signed_integral<UDT>::value)
-   value_test(false, is_standard_signed_integral<void>::value)
-   value_test(false, is_standard_signed_integral<bool>::value)
-   value_test(false, is_standard_signed_integral<char>::value)
-   value_test(true, is_standard_signed_integral<signed char>::value)
-   value_test(false, is_standard_signed_integral<unsigned char>::value)
-   value_test(false, is_standard_signed_integral<wchar_t>::value)
-   value_test(true, is_standard_signed_integral<short>::value)
-   value_test(false, is_standard_signed_integral<unsigned short>::value)
-   value_test(true, is_standard_signed_integral<int>::value)
-   value_test(false, is_standard_signed_integral<unsigned int>::value)
-   value_test(true, is_standard_signed_integral<long>::value)
-   value_test(false, is_standard_signed_integral<unsigned long>::value)
-   value_test(false, is_standard_signed_integral<float>::value)
-   value_test(false, is_standard_signed_integral<double>::value)
-   value_test(false, is_standard_signed_integral<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(false, is_standard_signed_integral<long long>::value)
-   value_test(false, is_standard_signed_integral<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(false, is_standard_signed_integral<__int64>::value)
-   value_test(false, is_standard_signed_integral<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_standard_arithmetic<UDT>::value)
-   value_test(false, is_standard_arithmetic<void>::value)
-   value_test(true, is_standard_arithmetic<bool>::value)
-   value_test(true, is_standard_arithmetic<char>::value)
-   value_test(true, is_standard_arithmetic<signed char>::value)
-   value_test(true, is_standard_arithmetic<unsigned char>::value)
-   value_test(true, is_standard_arithmetic<wchar_t>::value)
-   value_test(true, is_standard_arithmetic<short>::value)
-   value_test(true, is_standard_arithmetic<unsigned short>::value)
-   value_test(true, is_standard_arithmetic<int>::value)
-   value_test(true, is_standard_arithmetic<unsigned int>::value)
-   value_test(true, is_standard_arithmetic<long>::value)
-   value_test(true, is_standard_arithmetic<unsigned long>::value)
-   value_test(true, is_standard_arithmetic<float>::value)
-   value_test(true, is_standard_arithmetic<double>::value)
-   value_test(true, is_standard_arithmetic<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(false, is_standard_arithmetic<long long>::value)
-   value_test(false, is_standard_arithmetic<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(false, is_standard_arithmetic<__int64>::value)
-   value_test(false, is_standard_arithmetic<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_standard_fundamental<UDT>::value)
-   value_test(true, is_standard_fundamental<void>::value)
-   value_test(true, is_standard_fundamental<bool>::value)
-   value_test(true, is_standard_fundamental<char>::value)
-   value_test(true, is_standard_fundamental<signed char>::value)
-   value_test(true, is_standard_fundamental<unsigned char>::value)
-   value_test(true, is_standard_fundamental<wchar_t>::value)
-   value_test(true, is_standard_fundamental<short>::value)
-   value_test(true, is_standard_fundamental<unsigned short>::value)
-   value_test(true, is_standard_fundamental<int>::value)
-   value_test(true, is_standard_fundamental<unsigned int>::value)
-   value_test(true, is_standard_fundamental<long>::value)
-   value_test(true, is_standard_fundamental<unsigned long>::value)
-   value_test(true, is_standard_fundamental<float>::value)
-   value_test(true, is_standard_fundamental<double>::value)
-   value_test(true, is_standard_fundamental<long double>::value)
-   #ifdef ULLONG_MAX
-   value_test(false, is_standard_fundamental<long long>::value)
-   value_test(false, is_standard_fundamental<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(false, is_standard_fundamental<__int64>::value)
-   value_test(false, is_standard_fundamental<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_arithmetic<UDT>::value)
-   value_test(true, is_arithmetic<char>::value)
-   value_test(true, is_arithmetic<signed char>::value)
-   value_test(true, is_arithmetic<unsigned char>::value)
-   value_test(true, is_arithmetic<wchar_t>::value)
-   value_test(true, is_arithmetic<short>::value)
-   value_test(true, is_arithmetic<unsigned short>::value)
-   value_test(true, is_arithmetic<int>::value)
-   value_test(true, is_arithmetic<unsigned int>::value)
-   value_test(true, is_arithmetic<long>::value)
-   value_test(true, is_arithmetic<unsigned long>::value)
-   value_test(true, is_arithmetic<float>::value)
-   value_test(true, is_arithmetic<double>::value)
-   value_test(true, is_arithmetic<long double>::value)
-   value_test(true, is_arithmetic<bool>::value)
-   #ifdef ULLONG_MAX
-   value_test(true, is_arithmetic<long long>::value)
-   value_test(true, is_arithmetic<unsigned long long>::value)
-   #endif
-   #if defined(__BORLANDC__) || defined(_MSC_VER)
-   value_test(true, is_arithmetic<__int64>::value)
-   value_test(true, is_arithmetic<unsigned __int64>::value)
-   #endif
-
-   value_test(false, is_array<int>::value)
-   value_test(false, is_array<int*>::value)
-   value_test(true, is_array<int[2]>::value)
-   value_test(true, is_array<int[2][3]>::value)
-   value_test(true, is_array<UDT[2]>::value)
-
-   typedef void(*f1)();
-   typedef int(*f2)(int);
-   typedef int(*f3)(int, bool);
-   typedef void (UDT::*mf1)();
-   typedef int (UDT::*mf2)();
-   typedef int (UDT::*mf3)(int);
-   typedef int (UDT::*mf4)(int, float);
-
-   value_test(false, is_pointer<int>::value)
-   value_test(false, is_pointer<int&>::value)
-   value_test(true, is_pointer<int*>::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)
-   value_test(true, is_pointer<f1>::value)
-   value_test(true, is_pointer<f2>::value)
-   value_test(true, is_pointer<f3>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3
-   value_test(false, is_pointer<mf1>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3
-   value_test(false, is_pointer<mf2>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3
-   value_test(false, is_pointer<mf3>::value)
-   // Steve: was 'true', should be 'false', via 3.9.2p3
-   value_test(false, is_pointer<mf4>::value)
-
-   value_test(false, is_reference<bool>::value)
-   value_test(true, is_reference<int&>::value)
-   value_test(true, is_reference<const int&>::value)
-   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(false, is_class<int>::value)
-   value_test(false, is_class<const int>::value)
-   value_test(false, is_class<volatile int>::value)
-   value_test(false, is_class<int*>::value)
-   value_test(false, is_class<int* const>::value)
-   value_test(false, is_class<int[2]>::value)
-   value_test(false, is_class<int&>::value)
-   value_test(false, is_class<mf4>::value)
-   value_test(false, is_class<f1>::value)
-   value_test(false, is_class<enum_UDT>::value)
-   value_test(true, is_class<UDT>::value)
-   value_test(true, is_class<UDT const>::value)
-   value_test(true, is_class<UDT volatile>::value)
-   value_test(true, is_class<empty_UDT>::value)
-   value_test(true, is_class<std::iostream>::value)
-   value_test(false, is_class<UDT*>::value)
-   value_test(false, is_class<UDT[2]>::value)
-   value_test(false, is_class<UDT&>::value)
-
-   value_test(true, is_object<int>::value)
-   value_test(true, is_object<UDT>::value)
-   value_test(false, is_object<int&>::value)
-   value_test(false, is_object<void>::value)
-   value_test(true, is_standard_scalar<int>::value)
-   value_test(true, is_extension_scalar<void*>::value)
-
-   value_test(false, is_enum<int>::value)
-   value_test(true, is_enum<enum_UDT>::value)
-
-   value_test(false, is_member_pointer<f1>::value)
-   value_test(false, is_member_pointer<f2>::value)
-   value_test(false, is_member_pointer<f3>::value)
-   value_test(true, is_member_pointer<mf1>::value)
-   value_test(true, is_member_pointer<mf2>::value)
-   value_test(true, is_member_pointer<mf3>::value)
-   value_test(true, is_member_pointer<mf4>::value)
-
-   value_test(false, is_empty<int>::value)
-   value_test(false, is_empty<int*>::value)
-   value_test(false, is_empty<int&>::value)
-#ifdef __MWERKS__
-   // apparent compiler bug causes this to fail to compile:
-   value_fail(false, is_empty<int[2]>::value)
-#else
-   value_test(false, is_empty<int[2]>::value)
-#endif
-   value_test(false, is_empty<f1>::value)
-   value_test(false, is_empty<mf1>::value)
-   value_test(false, is_empty<UDT>::value)
-   value_test(true, is_empty<empty_UDT>::value)
-   value_test(true, is_empty<empty_POD_UDT>::value)
-   value_test(true, is_empty<empty_union_UDT>::value)
-   value_test(false, is_empty<enum_UDT>::value)
-
-   value_test(true, has_trivial_constructor<int>::value)
-   value_test(true, has_trivial_constructor<int*>::value)
-   value_test(true, has_trivial_constructor<int*const>::value)
-   value_test(true, has_trivial_constructor<const int>::value)
-   value_test(true, has_trivial_constructor<volatile int>::value)
-   value_test(true, has_trivial_constructor<int[2]>::value)
-   value_test(true, has_trivial_constructor<int[3][2]>::value)
-   value_test(true, has_trivial_constructor<int[2][4][5][6][3]>::value)
-   value_test(true, has_trivial_constructor<f1>::value)
-   value_test(true, has_trivial_constructor<mf2>::value)
-   value_test(false, has_trivial_constructor<UDT>::value)
-   value_test(true, has_trivial_constructor<empty_UDT>::value)
-   value_test(true, has_trivial_constructor<enum_UDT>::value)
-
-   value_test(true, has_trivial_copy<int>::value)
-   value_test(true, has_trivial_copy<int*>::value)
-   value_test(true, has_trivial_copy<int*const>::value)
-   value_test(true, has_trivial_copy<const int>::value)
-   // Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
-   value_test(true, has_trivial_copy<volatile int>::value)
-   value_test(true, has_trivial_copy<int[2]>::value)
-   value_test(true, has_trivial_copy<int[3][2]>::value)
-   value_test(true, has_trivial_copy<int[2][4][5][6][3]>::value)
-   value_test(true, has_trivial_copy<f1>::value)
-   value_test(true, has_trivial_copy<mf2>::value)
-   value_test(false, has_trivial_copy<UDT>::value)
-   value_test(true, has_trivial_copy<empty_UDT>::value)
-   value_test(true, has_trivial_copy<enum_UDT>::value)
-
-   value_test(true, has_trivial_assign<int>::value)
-   value_test(true, has_trivial_assign<int*>::value)
-   value_test(true, has_trivial_assign<int*const>::value)
-   value_test(true, has_trivial_assign<const int>::value)
-   // Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
-   value_test(true, has_trivial_assign<volatile int>::value)
-   value_test(true, has_trivial_assign<int[2]>::value)
-   value_test(true, has_trivial_assign<int[3][2]>::value)
-   value_test(true, has_trivial_assign<int[2][4][5][6][3]>::value)
-   value_test(true, has_trivial_assign<f1>::value)
-   value_test(true, has_trivial_assign<mf2>::value)
-   value_test(false, has_trivial_assign<UDT>::value)
-   value_test(true, has_trivial_assign<empty_UDT>::value)
-   value_test(true, has_trivial_assign<enum_UDT>::value)
-
-   value_test(true, has_trivial_destructor<int>::value)
-   value_test(true, has_trivial_destructor<int*>::value)
-   value_test(true, has_trivial_destructor<int*const>::value)
-   value_test(true, has_trivial_destructor<const int>::value)
-   value_test(true, has_trivial_destructor<volatile int>::value)
-   value_test(true, has_trivial_destructor<int[2]>::value)
-   value_test(true, has_trivial_destructor<int[3][2]>::value)
-   value_test(true, has_trivial_destructor<int[2][4][5][6][3]>::value)
-   value_test(true, has_trivial_destructor<f1>::value)
-   value_test(true, has_trivial_destructor<mf2>::value)
-   value_test(false, has_trivial_destructor<UDT>::value)
-   value_test(false, has_trivial_destructor<empty_UDT>::value)
-   value_test(true, has_trivial_destructor<enum_UDT>::value)
-
-   value_test(true, is_POD<int>::value)
-   value_test(true, is_POD<int*>::value)
-   // Steve: was 'true', should be 'false', via 3.9p10
-   value_test(false, is_POD<int&>::value)
-   value_test(true, is_POD<int*const>::value)
-   value_test(true, is_POD<const int>::value)
-   // Steve: was 'false', should be 'true', via 3.9p10
-   value_test(true, is_POD<volatile int>::value)
-   // Steve: was 'true', should be 'false', via 3.9p10
-   value_test(false, is_POD<const int&>::value)
-   value_test(true, is_POD<int[2]>::value)
-   value_test(true, is_POD<int[3][2]>::value)
-   value_test(true, is_POD<int[2][4][5][6][3]>::value)
-   value_test(true, is_POD<f1>::value)
-   value_test(true, is_POD<mf2>::value)
-   value_test(false, is_POD<UDT>::value)
-   value_test(false, is_POD<empty_UDT>::value)
-   value_test(true, is_POD<enum_UDT>::value)
-
-   value_test(true, (boost::is_convertible<Deriverd,Base>::value));
-   value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
-   value_test(true, (boost::is_convertible<Base,Base>::value));
-   value_test(false, (boost::is_convertible<Base,Deriverd>::value));
-   value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
-   value_test(false, (boost::is_convertible<NonDerived,Base>::value));
-   //value_test(false, (boost::is_convertible<boost::noncopyable, boost::noncopyable>::value));
-   value_test(true, (boost::is_convertible<float,int>::value));
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   value_test(false, (boost::is_convertible<float,void>::value));
-   value_test(false, (boost::is_convertible<void,float>::value));
-   value_test(true, (boost::is_convertible<void,void>::value));
-#endif
-   value_test(true, (boost::is_convertible<enum1, int>::value));
-   value_test(true, (boost::is_convertible<Deriverd*, Base*>::value));
-   value_test(false, (boost::is_convertible<Base*, Deriverd*>::value));
-   value_test(true, (boost::is_convertible<Deriverd&, Base&>::value));
-   value_test(false, (boost::is_convertible<Base&, Deriverd&>::value));
-   value_test(true, (boost::is_convertible<const Deriverd*, const Base*>::value));
-   value_test(false, (boost::is_convertible<const Base*, const Deriverd*>::value));
-   value_test(true, (boost::is_convertible<const Deriverd&, const Base&>::value));
-   value_test(false, (boost::is_convertible<const Base&, const Deriverd&>::value));
-
-   value_test(false, (boost::is_convertible<const int *, int*>::value));
-   value_test(false, (boost::is_convertible<const int&, int&>::value));
-   value_test(false, (boost::is_convertible<int*, int[2]>::value));
-   value_test(false, (boost::is_convertible<const int*, int[3]>::value));
-   value_test(true, (boost::is_convertible<const int&, int>::value));
-   value_test(true, (boost::is_convertible<int(&)[4], const int*>::value));
-   value_test(true, (boost::is_convertible<int(&)(int), int(*)(int)>::value));
-   value_test(true, (boost::is_convertible<int *, const int*>::value));
-   value_test(true, (boost::is_convertible<int&, const int&>::value));
-   value_test(true, (boost::is_convertible<int[2], int*>::value));
-   value_test(true, (boost::is_convertible<int[2], const int*>::value));
-   value_test(false, (boost::is_convertible<const int[2], int*>::value));
-
-   align_test(int);
-   align_test(char);
-   align_test(double);
-   align_test(int[4]);
-   align_test(int(*)(int));
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-   align_test(char&);
-   align_test(char (&)(int));
-   align_test(char(&)[4]);
-#endif
-   align_test(int*);
-   //align_test(const int);
-   align_test(VB);
-   align_test(VD);
-
-   std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
-   std::cin.get();
-   return failures;
-}
-
-
-
-
--- a/type_traits_test.hpp
+++ b/type_traits_test.hpp
@@ -1,106 +0,0 @@
- // boost::compressed_pair test program   
-    
- //  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
- //  distribute this software is granted provided this copyright notice appears   
- //  in all copies. This software is provided "as is" without express or implied   
- //  warranty, and with no claim as to its suitability for any purpose.   
-
-// common test code for type_traits_test.cpp/call_traits_test.cpp/compressed_pair_test.cpp
-
-
-#ifndef BOOST_TYPE_TRAITS_TEST_HPP
-#define BOOST_TYPE_TRAITS_TEST_HPP
-
-//
-// this one is here just to suppress warnings:
-//
-template <class T>
-bool do_compare(T i, T j)
-{
-   return i == j;
-}
-
-//
-// this one is to verify that a constant is indeed a
-// constant-integral-expression:
-//
-template <int>
-struct ct_checker
-{
-};
-
-#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
-#define BOOST_DO_JOIN2(X, Y) X ## Y
-#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
-
-
-#define value_test(v, x) ++test_count;\
-                         typedef ct_checker<(x)> BOOST_JOIN(this_is_a_compile_time_check_, __LINE__);\
-                         if(!do_compare((int)v,(int)x)){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
-#define value_fail(v, x) ++test_count; ++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#define type_test(v, x)  ++test_count;\
-                           if(do_compare(boost::is_same<v, x>::value, false)){\
-                           ++failures; \
-                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
-                           std::cout << "   expected type was " << #v << std::endl; \
-                           std::cout << "   " << typeid(boost::is_same<v, x>).name() << "::value is false" << std::endl; }
-#else
-#define type_test(v, x)  ++test_count;\
-                         if(typeid(v) != typeid(x)){\
-                           ++failures; \
-                           std::cout << "checking type of " << #x << "...failed" << std::endl; \
-                           std::cout << "   expected type was " << #v << std::endl; \
-                           std::cout << "   " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
-#endif
-
-template <class T>
-struct test_align
-{
-   struct padded
-   {
-      char c;
-      T t;
-   };
-   static void do_it()
-   {
-      padded p;
-      unsigned a = reinterpret_cast<char*>(&(p.t)) - reinterpret_cast<char*>(&p);
-      value_test(a, boost::alignment_of<T>::value);
-   }
-};
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct test_align<T&>
-{
-   static void do_it()
-   {
-      //
-      // we can't do the usual test because we can't take the address
-      // of a reference, so check that the result is the same as for a
-      // pointer type instead:
-      value_test(boost::alignment_of<T*>::value, boost::alignment_of<T&>::value);
-   }
-};
-#endif
-
-#define align_test(T) test_align<T>::do_it()
-
-//
-// define tests here
-unsigned failures = 0;
-unsigned test_count = 0;
-
-//
-// turn off some warnings:
-#ifdef __BORLANDC__
-#pragma option -w-8004
-#endif
-
-#ifdef BOOST_MSVC
-#pragma warning (disable: 4018)
-#endif
-
-
-#endif // BOOST_TYPE_TRAITS_TEST_HPP
--- a/utility.htm
+++ b/utility.htm
@@ -16,10 +16,11 @@
 <h2>Contents</h2>

 <ul>
-  <li>Template functions <a href="#functions next">next() and prior()</a></li>
+  <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>Template <a name="functions next">functions next</a>() and prior()</h2>
+<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+()
@@ -80,7 +81,7 @@ CodeWarrior 5.0, and Microsoft Visual C++ 6.0 sp 3.</p>
  <pre>// inside one of your own headers ...
 #include &lt;boost/utility.hpp&gt;

-class ResourceLadenFileSystem : noncopyable {
+class ResourceLadenFileSystem : boost::noncopyable {
 ...</pre>
 </blockquote>

@@ -92,7 +93,7 @@ destructor declarations. He says &quot;Probably this concern is misplaced, becau
 noncopyable will be used mostly for classes which own resources and thus have non-trivial destruction semantics.&quot;</p>
 <hr>
 <p>Revised&nbsp; <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
-->26 January, 2000<!--webbot bot="Timestamp" endspan i-checksum="38194"
+-->28 February, 2001<!--webbot bot="Timestamp" endspan i-checksum="40412"
 -->
 </p>
 <p><EFBFBD> Copyright boost.org 1999. Permission to copy, use, modify, sell and