This commit was manufactured by cvs2svn to create tag

'Version_1_25_1'. [SVN r11623]
Removed defunct boost::tied (thanks, Daryle Walker)
2001-11-07 10:35:13 +00:00 · 2001-11-07 10:35:12 +00:00 · 2001-11-06 16:09:14 +00:00 · 2001-11-06 16:05:25 +00:00 · 2001-11-06 15:52:56 +00:00 · 2001-11-05 21:03:59 +00:00
44 changed files with 4338 additions and 1399 deletions
--- a/Assignable.html
+++ b/Assignable.html
@ -100,7 +100,7 @@ Assignment
 </UL>

 <h3>See also</h3>
-<a href="http://www.sgi.com/Technology/STL/DefaultConstructible.html">DefaultConstructible</A>
+<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</A>
 and 
 <A href="./CopyConstructible.html">CopyConstructible</A>

--- a/CopyConstructible.html
+++ b/CopyConstructible.html
@ -11,7 +11,7 @@
  -- purpose.  It is provided "as is" without express or implied warranty.
  -->
 <Head>
-<Title>CopyConstructible</Title>
+<Title>Copy Constructible</Title>
 </HEAD>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
        ALINK="#ff0000"> 
@ -19,10 +19,10 @@
     ALT="C++ Boost" width="277" height="86"> 
 <!--end header-->
 <BR Clear>
-<H1>CopyConstructible</H1>
+<H1>Copy Constructible</H1>

 <h3>Description</h3>
-A type is CopyConstructible if it is possible to copy objects of that
+A type is Copy Constructible if it is possible to copy objects of that
 type.

 <h3>Notation</h3>
@ -32,7 +32,7 @@ type.
 <tt>T</tt>
 </TD>
 <TD VAlign=top>
-is type that is a model of CopyConstructible
+is type that is a model of Copy Constructible
 </TD>
 </TR>

@ -194,9 +194,9 @@ denotes the address of <tt>u</tt>

 <h3>See also</h3>
 <A
-href="http://www.sgi.com/Technology/STL/DefaultConstructible.html">DefaultConstructible</A>
+href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</A>
 and 
-<A href="http://www.sgi.com/Technology/STL/Assignable.html">Assignable</A>
+<A hrefa="./Assignable.html">Assignable</A>

 <br>
 <HR>
--- a/LessThanComparable.html
+++ b/LessThanComparable.html
@ -196,7 +196,7 @@ 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>
+<A href="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</A>, <A href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html">StrictWeakOrdering</A>



--- a/MultiPassInputIterator.html
+++ b/MultiPassInputIterator.html
@ -21,21 +21,21 @@

 <H2>
 <A NAME="concept:MultiPassInputIterator"></A>
-MultiPassInputIterator
+Multi-Pass Input Iterator
 </H2>

 This concept is a refinement of <a
-href="http://www.sgi.com/Technology/STL/InputIterator.html">InputIterator</a>,
+href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>,
 adding the requirements that the iterator can be used to make multiple
 passes through a range, and that if <TT>it1 == it2</TT> and
 <TT>it1</TT> is dereferenceable then <TT>++it1 == ++it2</TT>. The
-MultiPassInputIterator is very similar to the <a
-href="http://www.sgi.com/Technology/STL/ForwardIterator.hmtl">ForwardIterator</a>. The
+Multi-Pass Input Iterator is very similar to the <a
+href="http://www.sgi.com/tech/stl/ForwardIterator.hmtl">Forward Iterator</a>. The
 only difference is that a <a
-href="http://www.sgi.com/Technology/STL/ForwardIterator.hmtl">ForwardIterator</a>
+href="http://www.sgi.com/tech/stl/ForwardIterator.hmtl">Forward Iterator</a>
 requires the <TT>reference</TT> type to be <TT>value_type&amp;</TT>, whereas
 MultiPassInputIterator is like <a
-href="http://www.sgi.com/Technology/STL/InputIterator.html">InputIterator</a>
+href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
 in that the <TT>reference</TT> type merely has to be convertible to
 <TT>value_type</TT>.

@ -44,29 +44,29 @@ in that the <TT>reference</TT> type merely has to be convertible to

 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
+<p> I think that introducing Multi-Pass Input Iterator isn't the right
+solution. Do you also want to define Multi-Pass Bidirectionnal Iterator
+and Multi-Pass Random Access Iterator ? I don't, definitly. It only
 confuses the issue. The problem lies into the existing hierarchy of
 iterators, which mixes movabillity, modifiabillity and lvalue-ness,
 and these are clearly independant.

-<p> The terms Forward, Bidirectionnal and RandomAccess are about
+<p> The terms Forward, Bidirectionnal and Random Access are about
 movabillity and shouldn't be used to mean anything else.  In a
 completly orthogonal way, iterators can be immutable, mutable, or
 neither.  Lvalueness of iterators is also orthogonal with
-immutabillity.  With these clean concepts, your MultiPassInputIterator
-is just called a ForwardIterator.
+immutabillity.  With these clean concepts, your Multi-Pass Input Iterator
+is just called a Forward Iterator.

 <p>                
 Other translations are:<br>
-std::ForwardIterator -> ForwardIterator & LvalueIterator<br>
-std::BidirectionnalIterator -> BidirectionnalIterator & LvalueIterator<br>
-std::RandomAccessIterator -> RandomAccessIterator & LvalueIterator<br>
+std::Forward Iterator -> ForwardIterator & Lvalue Iterator<br>
+std::Bidirectionnal Iterator -> Bidirectionnal Iterator & Lvalue Iterator<br>
+std::Random Access Iterator -> Random Access Iterator & Lvalue Iterator<br>

 <p>
 Note that in practice the only operation not allowed on my 
-ForwardIterator which is allowed on std::ForwardIterator is 
+Forward Iterator which is allowed on std::Forward Iterator is 
 <tt>&*it</tt>. I think that <tt>&*</tt> is rarely needed in generic code.

 <p>
@ -75,9 +75,9 @@ 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.
+are based on the old definition of Forward Iterator. The right course
+of action is to get Forward Iterator, etc. changed in the C++ standard.
+Once that is done we can drop Multi-Pass Input Iterator.


 <br>
@ -85,7 +85,7 @@ Once that is done we can drop MultiPassInputIterator.
 <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>)
+<a HREF="../../people/jeremy_siek.htm">Jeremy Siek</a>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
 </TD></TR></TABLE>

 </BODY>
--- a/base_from_member.html
+++ b/base_from_member.html
@ -0,0 +1,341 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
+<html>
+<head>
+<title>Boost: Base-from-Member Idiom Documentation</title>
+</head>
+
+<body bgcolor="white" link="blue" text="black" vlink="purple" alink="red"> 
+<h1><img src="../../c++boost.gif" alt="C++ Boost" align="middle"
+width="277" height="86">Base-from-Member Idiom</h1>
+
+<p>The class template <code>boost::base_from_member</code> provides
+a workaround for a class that needs to initialize a base class with a
+member.  The class template is in <cite><a
+href="../../boost/utility/base_from_member.hpp">boost/utility/base_from_member.hpp</a></cite>
+which is included in <i><a href="../../boost/utility.hpp">boost/utility.hpp</a></i>.
+The class template is forward declared in <i><a href="../../boost/utility_fwd.hpp">boost/utility_fwd.hpp</a></i>.</p>
+
+<p>There is test/example code in <cite><a
+href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.</p>
+
+<h2><a name="contents">Contents</a></h2>
+
+<ul>
+	<li><a href="#contents">Contents</a></li>
+	<li><a href="#rationale">Rationale</a></li>
+	<li><a href="#synopsis">Synopsis</a></li>
+	<li><a href="#usage">Usage</a></li>
+	<li><a href="#example">Example</a></li>
+	<li><a href="#credits">Credits</a>
+		<ul>
+			<li><a href="#contributors">Contributors</a></li>
+		</ul></li>
+</ul>
+
+<h2><a name="rationale">Rationale</a></h2>
+
+<p>When developing a class, sometimes a base class needs to be
+initialized with a member of the current class.  As a na&iuml;ve
+example:</p>
+
+<blockquote><pre>
+#include &lt;streambuf&gt;  <i>// for std::streambuf</i>
+#include &lt;ostream&gt;    <i>// for std::ostream</i>
+
+class fdoutbuf
+    : public std::streambuf
+{
+public:
+    explicit fdoutbuf( int fd );
+    //...
+};
+
+class fdostream
+    : public std::ostream
+{
+protected:
+    fdoutbuf buf;
+public:
+    explicit fdostream( int fd )
+        : buf( fd ), std::ostream( &amp;buf )
+        {}
+    //...
+};
+</pre></blockquote>
+
+<p>This is undefined because C++'s initialization order mandates that
+the base class is initialized before the member it uses.  Ron Klatchko
+developed a way around this by using the initialization order in his
+favor.  Base classes are intialized in order of declaration, so moving
+the desired member to another base class, that is initialized before the
+desired base class, can ensure proper initialization.</p>
+
+<p>A custom base class can be made for this idiom:</p>
+
+<blockquote><pre>
+#include &lt;streambuf&gt;  <i>// for std::streambuf</i>
+#include &lt;ostream&gt;    <i>// for std::ostream</i>
+
+class fdoutbuf
+    : public std::streambuf
+{
+public:
+    explicit fdoutbuf( int fd );
+    //...
+};
+
+struct fdostream_pbase
+{
+    fdoutbuf sbuffer;
+
+    explicit fdostream_pbase( int fd )
+        : sbuffer( fd )
+        {}
+};
+
+class fdostream
+    : private fdostream_pbase
+    , public std::ostream
+{
+    typedef fdostream_pbase  pbase_type;
+    typedef std::ostream     base_type;
+
+public:
+    explicit fdostream( int fd )
+        : pbase_type( fd ), base_type( &amp;sbuffer )
+        {}
+    //...
+};
+</pre></blockquote>
+
+<p>Other projects can use similar custom base classes.  The technique is basic enough to make a template, with a sample template class in this library.  The main template parameter is the type of the enclosed member.  The template class has several (explicit) constructor member templates, which implicitly type the constructor arguments and pass them to the member.  The template class uses implicit copy construction and assignment, cancelling them if the enclosed member is non-copyable.</p>
+
+<p>Manually coding a base class may be better if the construction
+and/or copying needs are too complex for the supplied template class,
+or if the compiler is not advanced enough to use it.</p>
+
+<p>Since base classes are unnamed, a class cannot have multiple (direct)
+base classes of the same type.  The supplied template class has an
+extra template parameter, an integer, that exists solely to provide type
+differentiation.  This parameter has a default value so a single use of a
+particular member type does not need to concern itself with the integer.</p>
+
+<h2><a name="synopsis">Synopsis</a></h2>
+
+<blockquote><pre>
+template &lt; typename MemberType, int UniqueID = 0 &gt;
+class boost::base_from_member
+{
+protected:
+    MemberType  member;
+
+    explicit  base_from_member();
+
+    template&lt; typename T1 &gt;
+    explicit  base_from_member( T1 x1 );
+
+    //...
+
+    template&lt; typename T1, typename T2, typename T3 &gt;
+    explicit  base_from_member( T1 x1, T2 x2, T3 x3 );
+};
+</pre></blockquote>
+
+<p>The class template has a first template parameter
+<var>MemberType</var> representing the type of the based-member.
+It has a last template parameter <var>UniqueID</var>, that is an
+<code>int</code>, to differentiate between multiple base classes that use
+the same based-member type.  The last template parameter has a default
+value of zero if it is omitted.  The class template has a protected
+data member called <var>member</var> that the derived class can use
+for later base classes (or itself).</p>
+
+<p>There is a default constructor and several constructor member
+templates.  These constructor templates can take as many arguments
+(currently up to three) as possible and pass them to a constructor of
+the data member.  Since C++ does not allow any way to explicitly state
+the template parameters of a templated constructor, make sure that
+the arguments are already close as possible to the actual type used in
+the data member's desired constructor.</p>
+
+<h2><a name="usage">Usage</a></h2>
+
+<p>With the starting example, the <code>fdoutbuf</code> sub-object needs
+to be encapsulated in a base class that is inheirited before
+<code>std::ostream</code>.</p>
+
+<blockquote><pre>
+#include &lt;boost/utility/base_from_member.hpp&gt;
+
+#include &lt;streambuf&gt;  <i>// for std::streambuf</i>
+#include &lt;ostream&gt;    <i>// for std::ostream</i>
+
+class fdoutbuf
+    : public std::streambuf
+{
+public:
+    explicit fdoutbuf( int fd );
+    //...
+};
+
+class fdostream
+    : private boost::base_from_member&lt;fdoutbuf&gt;
+    , public std::ostream
+{
+    // Helper typedef's
+    typedef boost::base_from_member&lt;fdoutbuf&gt;  pbase_type;
+    typedef std::ostream                        base_type;
+
+public:
+    explicit fdostream( int fd )
+        : pbase_type( fd ), base_type( &amp;member )
+        {}
+    //...
+};
+</pre></blockquote>
+
+<p>The base-from-member idiom is an implementation detail, so it
+should not be visible to the clients (or any derived classes) of
+<code>fdostream</code>.  Due to the initialization order, the
+<code>fdoutbuf</code> sub-object will get initialized before the
+<code>std::ostream</code> sub-object does, making the former
+sub-object safe to use in the latter sub-object's construction.  Since the
+<code>fdoutbuf</code> sub-object of the final type is the only sub-object
+with the name &quot;member,&quot; that name can be used
+unqualified within the final class.</p>
+
+<h2><a name="example">Example</a></h2>
+
+<p>The base-from-member class templates should commonly involve
+only one base-from-member sub-object, usually for attaching a
+stream-buffer to an I/O stream.  The next example demonstrates how
+to use multiple base-from-member sub-objects and the resulting
+qualification issues.</p>
+
+<blockquote><pre>
+#include &lt;boost/utility/base_from_member.hpp&gt;
+
+#include &lt;cstddef&gt;  <i>// for NULL</i>
+
+struct an_int
+{
+    int  y;
+
+    an_int( float yf );
+};
+
+class switcher
+{
+public:
+    switcher();
+    switcher( double, int * );
+    //...
+};
+
+class flow_regulator
+{
+public:
+    flow_regulator( switcher &amp;, switcher &amp; );
+    //...
+};
+
+template &lt; unsigned Size &gt;
+class fan
+{
+public:
+    explicit fan( switcher );
+    //...
+};
+
+class system
+    : private boost::base_from_member&lt;an_int&gt;
+    , private boost::base_from_member&lt;switcher&gt;
+    , private boost::base_from_member&lt;switcher, 1&gt;
+    , private boost::base_from_member&lt;switcher, 2&gt;
+    , protected flow_regulator
+    , public fan&lt;6&gt;
+{
+    // Helper typedef's
+    typedef boost::base_from_member&lt;an_int&gt;       pbase0_type;
+    typedef boost::base_from_member&lt;switcher&gt;     pbase1_type;
+    typedef boost::base_from_member&lt;switcher, 1&gt;  pbase2_type;
+    typedef boost::base_from_member&lt;switcher, 2&gt;  pbase3_type;
+
+    typedef flow_regulator  base1_type;
+    typedef fan&lt;6&gt;          base2_type;
+
+public:
+    system( double x );
+    //...
+};
+
+system::system( double x )
+    : pbase0_type( 0.2 )
+    , pbase1_type()
+    , pbase2_type( -16, &amp;this-&gt;pbase0_type::member )
+    , pbase3_type( x, static_cast&lt;int *&gt;(NULL) )
+    , base1_type( pbase3_type::member, pbase1_type::member )
+    , base2_type( pbase2_type::member )
+{
+    //...
+}
+</pre></blockquote>
+
+<p>The final class has multiple sub-objects with the name
+&quot;member,&quot; so any use of that name needs qualification by
+a name of the appropriate base type.  (Using <code>typedef</code>s
+ease mentioning the base types.)  However, the fix introduces a new
+problem when a pointer is needed.  Using the address operator with
+a sub-object qualified with its class's name results in a pointer-to-member
+(here, having a type of <code>an_int boost::base_from_member&lt;an_int,
+0&gt; :: *</code>) instead of a pointer to the member (having a type of
+<code>an_int *</code>).  The new problem is fixed by qualifying the
+sub-object with &quot;<code>this-&gt;</code>,&quot; and is needed just
+for pointers, and not for references or values.</p>
+
+<p>There are some argument conversions in the initialization.  The
+constructor argument for <code>pbase0_type</code> is converted from
+<code>double</code> to <code>float</code>.  The first constructor
+argument for <code>pbase2_type</code> is converted from <code>int</code>
+to <code>double</code>.  The second constructor argument for
+<code>pbase3_type</code> is a special case of necessary conversion; all
+forms of the null-pointer literal in C++ also look like compile-time
+integral expressions, so C++ always interprets such code as an integer
+when it has overloads that can take either an integer or a pointer.  The
+last conversion is necessary for the compiler to call a constructor form
+with the exact pointer type used in <code>switcher</code>'s constructor.</p>
+
+<h2><a name="credits">Credits</a></h2>
+
+<h3><a name="contributors">Contributors</a></h3>
+
+<dl>
+	<dt><a href="../../people/ed_brey.htm">Ed Brey</a>
+	<dd>Suggested some interface changes.
+
+	<dt>Ron Klatchko (<a href="mailto:ron@crl.com">ron@crl.com</a>)
+	<dd>Invented the idiom of how to use a class member for initializing
+		a base class.
+
+	<dt><a href="../../people/dietmar_kuehl.htm">Dietmar Kuehl</a>
+	<dd>Popularized the base-from-member idiom in his
+		<a href="http://www.informatik.uni-konstanz.de/~kuehl/c++/iostream/">IOStream
+		example classes</a>.
+
+	<dt><a href="../../people/daryle_walker.html">Daryle Walker</a>
+	<dd>Started the library.  Contributed the test file <cite><a
+		href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.
+</dl>
+
+<hr>
+
+<p>Revised: 22 August 2001</p>
+
+<p>Copyright &copy; boost.org 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 &quot;as
+is&quot; without express or implied warranty, and with no claim as to
+its suitability for any purpose.</p>
+
+</body>
+</html>
--- a/base_from_member_test.cpp
+++ b/base_from_member_test.cpp
@ -0,0 +1,597 @@
+//  Boost test program for base-from-member class templates  -----------------//
+
+//  (C) Copyright Daryle Walker 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
+//  29 Aug 2001  Initial Version (Daryle Walker)
+
+#define  BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>  // for BOOST_TEST, main
+
+#include <boost/config.hpp>   // for BOOST_NO_MEMBER_TEMPLATES
+#include <boost/cstdlib.hpp>  // for boost::exit_success
+#include <boost/utility.hpp>  // for boost::noncopyable
+
+#include <boost/utility/base_from_member.hpp>  // for boost::base_from_member
+
+#include <functional>  // for std::binary_function, std::less
+#include <iostream>    // for std::cout (std::ostream, std::endl indirectly)
+#include <set>         // for std::set
+#include <typeinfo>    // for std::type_info
+#include <utility>     // for std::pair, std::make_pair
+#include <vector>      // for std::vector
+
+
+// Control if extra information is printed
+#ifndef CONTROL_EXTRA_PRINTING
+#define CONTROL_EXTRA_PRINTING  1
+#endif
+
+
+// A (sub)object can be identified by its memory location and its type.
+// Both are needed since an object can start at the same place as its
+// first base class subobject and/or contained subobject.
+typedef std::pair< void *, std::type_info const * >  object_id;
+
+// Object IDs need to be printed
+std::ostream &  operator <<( std::ostream &os, object_id const &oi );
+
+// A way to generate an object ID
+template < typename T >
+  object_id  identify( T &obj );
+
+// A custom comparison type is needed
+struct object_id_compare
+    : std::binary_function<object_id, object_id, bool>
+{
+    bool  operator ()( object_id const &a, object_id const &b ) const;
+
+};  // object_id_compare
+
+// A singleton of this type coordinates the acknowledgements
+// of objects being created and used.
+class object_registrar
+    : boost::noncopyable
+{
+public:
+
+    #ifndef BOOST_NO_MEMBER_TEMPLATES
+    template < typename T >
+        void  register_object( T &obj )
+            { this->register_object_imp( identify(obj) ); }
+    template < typename T, typename U >
+        void  register_use( T &owner, U &owned )
+            { this->register_use_imp( identify(owner), identify(owned) ); }
+    template < typename T, typename U >
+        void  unregister_use( T &owner, U &owned )
+            { this->unregister_use_imp( identify(owner), identify(owned) ); }
+    template < typename T >
+        void  unregister_object( T &obj )
+            { this->unregister_object_imp( identify(obj) ); }
+    #endif
+
+    void  register_object_imp( object_id obj );
+    void  register_use_imp( object_id owner, object_id owned );
+    void  unregister_use_imp( object_id owner, object_id owned );
+    void  unregister_object_imp( object_id obj );
+
+    typedef std::set<object_id, object_id_compare>  set_type;
+
+    typedef std::vector<object_id>  error_record_type;
+    typedef std::vector< std::pair<object_id, object_id> >  error_pair_type;
+
+    set_type  db_;
+
+    error_pair_type    defrauders_in_, defrauders_out_;
+    error_record_type  overeager_, overkilled_;
+
+};  // object_registrar
+
+// A sample type to be used by containing types
+class base_or_member
+{
+public:
+    explicit  base_or_member( int x = 1, double y = -0.25 );
+             ~base_or_member();
+
+};  // base_or_member
+
+// A sample type that uses base_or_member, used
+// as a base for the main demonstration classes
+class base_class
+{
+public:
+    explicit  base_class( base_or_member &x, base_or_member *y = 0,
+     base_or_member *z = 0 );
+
+    ~base_class();
+
+private:
+    base_or_member  *x_, *y_, *z_;
+
+};  // base_class
+
+// This bad class demonstrates the direct method of a base class needing
+// to be initialized by a member.  This is improper since the member
+// isn't initialized until after the base class.
+class bad_class
+    : public base_class
+{
+public:
+     bad_class();
+    ~bad_class();
+
+private:
+    base_or_member  x_;
+
+};  // bad_class
+
+// The first good class demonstrates the correct way to initialize a
+// base class with a member.  The member is changed to another base
+// class, one that is initialized before the base that needs it.
+class good_class_1
+    : private boost::base_from_member<base_or_member>
+    , public base_class
+{
+    typedef boost::base_from_member<base_or_member>  pbase_type;
+    typedef base_class                                base_type;
+
+public:
+     good_class_1();
+    ~good_class_1();
+
+};  // good_class_1
+
+// The second good class also demonstrates the correct way to initialize
+// base classes with other subobjects.  This class uses the other helpers
+// in the library, and shows the technique of using two base subobjects
+// of the "same" type.
+class good_class_2
+    : private boost::base_from_member<base_or_member, 0>
+    , private boost::base_from_member<base_or_member, 1>
+    , private boost::base_from_member<base_or_member, 2>
+    , public base_class
+{
+    typedef boost::base_from_member<base_or_member, 0>  pbase_type0;
+    typedef boost::base_from_member<base_or_member, 1>  pbase_type1;
+    typedef boost::base_from_member<base_or_member, 2>  pbase_type2;
+    typedef base_class                                   base_type;
+
+public:
+     good_class_2();
+    ~good_class_2();
+
+};  // good_class_2
+
+// Declare/define the single object registrar
+object_registrar  obj_reg;
+
+
+// Main functionality
+int
+test_main( int , char * [] )
+{
+    BOOST_TEST( obj_reg.db_.empty() );
+    BOOST_TEST( obj_reg.defrauders_in_.empty() );
+    BOOST_TEST( obj_reg.defrauders_out_.empty() );
+    BOOST_TEST( obj_reg.overeager_.empty() );
+    BOOST_TEST( obj_reg.overkilled_.empty() );
+
+    // Make a separate block to examine pre- and post-effects
+    {
+        using std::cout;
+        using std::endl;
+
+        bad_class  bc;
+        BOOST_TEST( obj_reg.db_.size() == 3 );
+        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
+
+        good_class_1  gc1;
+        BOOST_TEST( obj_reg.db_.size() == 6 );
+        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
+
+        good_class_2  gc2;
+        BOOST_TEST( obj_reg.db_.size() == 11 );
+        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
+
+        BOOST_TEST( obj_reg.defrauders_out_.empty() );
+        BOOST_TEST( obj_reg.overeager_.empty() );
+        BOOST_TEST( obj_reg.overkilled_.empty() );
+
+        // Getting the addresses of the objects ensure
+        // that they're used, and not optimized away.
+        cout << "Object 'bc' is at " << &bc << '.' << endl;
+        cout << "Object 'gc1' is at " << &gc1 << '.' << endl;
+        cout << "Object 'gc2' is at " << &gc2 << '.' << endl;
+    }
+
+    BOOST_TEST( obj_reg.db_.empty() );
+    BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
+    BOOST_TEST( obj_reg.defrauders_out_.size() == 1 );
+    BOOST_TEST( obj_reg.overeager_.empty() );
+    BOOST_TEST( obj_reg.overkilled_.empty() );
+
+    return boost::exit_success;
+}
+
+
+// Print an object's ID
+std::ostream &
+operator <<
+(
+    std::ostream &     os,
+    object_id const &  oi
+)
+{
+    // I had an std::ostringstream to help, but I did not need it since
+    // the program never screws around with formatting.  Worse, using
+    // std::ostringstream is an issue with some compilers.
+
+    return os << '[' << ( oi.second ? oi.second->name() : "NOTHING" )
+     << " at " << oi.first << ']';
+}
+
+// Get an object ID given an object
+template < typename T >
+inline
+object_id
+identify
+(
+    T &  obj
+)
+{
+    return std::make_pair( static_cast<void *>(&obj), &(typeid( obj )) );
+}
+
+// Compare two object IDs
+bool
+object_id_compare::operator ()
+(
+    object_id const &  a,
+    object_id const &  b
+) const
+{
+    std::less<void *>  vp_cmp;
+    if ( vp_cmp(a.first, b.first) )
+    {
+        return true;
+    }
+    else if ( vp_cmp(b.first, a.first) )
+    {
+        return false;
+    }
+    else
+    {
+        // object pointers are equal, compare the types
+        if ( a.second == b.second )
+        {
+            return false;
+        }
+        else if ( !a.second )
+        {
+            return true;   // NULL preceeds anything else
+        }
+        else if ( !b.second )
+        {
+            return false;  // NULL preceeds anything else
+        }
+        else
+        {
+            return a.second->before( *b.second );
+        }
+    }
+}
+
+// Let an object register its existence
+void
+object_registrar::register_object_imp
+(
+    object_id  obj
+)
+{
+    if ( db_.count(obj) <= 0 )
+    {
+        db_.insert( obj );
+
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << "Registered " << obj << '.' << std::endl;
+        #endif
+    }
+    else
+    {
+        overeager_.push_back( obj );
+
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << "Attempted to register a non-existant " << obj
+         << '.' << std::endl;
+        #endif
+    }
+}
+
+// Let an object register its use of another object
+void
+object_registrar::register_use_imp
+(
+    object_id  owner,
+    object_id  owned
+)
+{
+    if ( db_.count(owned) > 0 )
+    {
+        // We don't care to record usage registrations
+    }
+    else
+    {
+        defrauders_in_.push_back( std::make_pair(owner, owned) );
+
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << "Attempted to own a non-existant " << owned
+         << " by " << owner << '.' << std::endl;
+        #endif
+    }
+}
+
+// Let an object un-register its use of another object
+void
+object_registrar::unregister_use_imp
+(
+    object_id  owner,
+    object_id  owned
+)
+{
+    if ( db_.count(owned) > 0 )
+    {
+        // We don't care to record usage un-registrations
+    }
+    else
+    {
+        defrauders_out_.push_back( std::make_pair(owner, owned) );
+
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << "Attempted to disown a non-existant " << owned
+         << " by " << owner << '.' << std::endl;
+        #endif
+    }
+}
+
+// Let an object un-register its existence
+void
+object_registrar::unregister_object_imp
+(
+    object_id  obj
+)
+{
+    set_type::iterator const  i = db_.find( obj );
+
+    if ( i != db_.end() )
+    {
+        db_.erase( i );
+
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << "Unregistered " << obj << '.' << std::endl;
+        #endif
+    }
+    else
+    {
+        overkilled_.push_back( obj );
+
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << "Attempted to unregister a non-existant " << obj
+         << '.' << std::endl;
+        #endif
+    }
+}
+
+// Macros to abstract the registration of objects
+#ifndef BOOST_NO_MEMBER_TEMPLATES
+#define PRIVATE_REGISTER_BIRTH(o)     obj_reg.register_object( (o) )
+#define PRIVATE_REGISTER_DEATH(o)     obj_reg.unregister_object( (o) )
+#define PRIVATE_REGISTER_USE(o, w)    obj_reg.register_use( (o), (w) )
+#define PRIVATE_UNREGISTER_USE(o, w)  obj_reg.unregister_use( (o), (w) )
+#else
+#define PRIVATE_REGISTER_BIRTH(o)     obj_reg.register_object_imp( \
+ identify((o)) )
+#define PRIVATE_REGISTER_DEATH(o)     obj_reg.unregister_object_imp( \
+ identify((o)) )
+#define PRIVATE_REGISTER_USE(o, w)    obj_reg.register_use_imp( identify((o)), \
+ identify((w)) )
+#define PRIVATE_UNREGISTER_USE(o, w)  obj_reg.unregister_use_imp( \
+ identify((o)), identify((w)) )
+#endif
+
+// Create a base_or_member, with arguments to simulate member initializations
+base_or_member::base_or_member
+(
+    int     x,  // = 1
+    double  y   // = -0.25
+)
+{
+    PRIVATE_REGISTER_BIRTH( *this );
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << "\tMy x-factor is " << x << " and my y-factor is " << y
+     << '.' << std::endl;
+    #endif
+}
+
+// Destroy a base_or_member
+inline
+base_or_member::~base_or_member
+(
+)
+{
+    PRIVATE_REGISTER_DEATH( *this );
+}
+
+// Create a base_class, registering any objects used
+base_class::base_class
+(
+    base_or_member &  x,
+    base_or_member *  y,  // = 0
+    base_or_member *  z   // = 0
+)
+    : x_( &x ), y_( y ), z_( z )
+{
+    PRIVATE_REGISTER_BIRTH( *this );
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << "\tMy x-factor is " << x_;
+    #endif
+
+    PRIVATE_REGISTER_USE( *this, *x_ );
+
+    if ( y_ )
+    {
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << ", my y-factor is " << y_;
+        #endif
+
+        PRIVATE_REGISTER_USE( *this, *y_ );
+    }
+
+    if ( z_ )
+    {
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << ", my z-factor is " << z_;
+        #endif
+
+        PRIVATE_REGISTER_USE( *this, *z_ );
+    }
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << '.' << std::endl;
+    #endif
+}
+
+// Destroy a base_class, unregistering the objects it uses
+base_class::~base_class
+(
+)
+{
+    PRIVATE_REGISTER_DEATH( *this );
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << "\tMy x-factor was " << x_;
+    #endif
+
+    PRIVATE_UNREGISTER_USE( *this, *x_ );
+
+    if ( y_ )
+    {
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << ", my y-factor was " << y_;
+        #endif
+
+        PRIVATE_UNREGISTER_USE( *this, *y_ );
+    }
+
+    if ( z_ )
+    {
+        #if CONTROL_EXTRA_PRINTING
+        std::cout << ", my z-factor was " << z_;
+        #endif
+
+        PRIVATE_UNREGISTER_USE( *this, *z_ );
+    }
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << '.' << std::endl;
+    #endif
+}
+
+// Create a bad_class, noting the improper construction order
+bad_class::bad_class
+(
+)
+    : x_( -7, 16.75 ), base_class( x_ )  // this order doesn't matter
+{
+    PRIVATE_REGISTER_BIRTH( *this );
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << "\tMy factor is at " << &x_
+     << " and my base is at " << static_cast<base_class *>(this) << '.'
+     << std::endl;
+    #endif
+}
+
+// Destroy a bad_class, noting the improper destruction order
+bad_class::~bad_class
+(
+)
+{
+    PRIVATE_REGISTER_DEATH( *this );
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << "\tMy factor was at " << &x_
+     << " and my base was at " << static_cast<base_class *>(this)
+     << '.' << std::endl;
+    #endif
+}
+
+// Create a good_class_1, noting the proper construction order
+good_class_1::good_class_1
+(
+)
+    : pbase_type( 8 ), base_type( member )
+{
+    PRIVATE_REGISTER_BIRTH( *this );
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << "\tMy factor is at " << &member
+     << " and my base is at " << static_cast<base_class *>(this) << '.'
+     << std::endl;
+    #endif
+}
+
+// Destroy a good_class_1, noting the proper destruction order
+good_class_1::~good_class_1
+(
+)
+{
+    PRIVATE_REGISTER_DEATH( *this );
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << "\tMy factor was at " << &member
+     << " and my base was at " << static_cast<base_class *>(this)
+     << '.' << std::endl;
+    #endif
+}
+
+// Create a good_class_2, noting the proper construction order
+good_class_2::good_class_2
+(
+)
+    : pbase_type0(), pbase_type1(-16, 0.125), pbase_type2(2, -3)
+    , base_type( pbase_type1::member, &this->pbase_type0::member,
+       &this->pbase_type2::member )
+{
+    PRIVATE_REGISTER_BIRTH( *this );
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << "\tMy factors are at " << &this->pbase_type0::member
+     << ", " << &this->pbase_type1::member << ", "
+     << &this->pbase_type2::member << ", and my base is at "
+     << static_cast<base_class *>(this) << '.' << std::endl;
+    #endif
+}
+
+// Destroy a good_class_2, noting the proper destruction order
+good_class_2::~good_class_2
+(
+)
+{
+    PRIVATE_REGISTER_DEATH( *this );
+
+    #if CONTROL_EXTRA_PRINTING
+    std::cout << "\tMy factors were at " << &this->pbase_type0::member
+     << ", " << &this->pbase_type1::member << ", "
+     << &this->pbase_type2::member << ", and my base was at "
+     << static_cast<base_class *>(this) << '.' << std::endl;
+    #endif
+}
--- a/call_traits.htm
+++ b/call_traits.htm
@ -5,7 +5,7 @@
 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">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <title>Call Traits</title>
 </head>

@ -751,7 +751,7 @@ 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>
+discussion list at <a href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.</p>

 <p>.</p>

--- a/call_traits_test.cpp
+++ b/call_traits_test.cpp
@ -17,6 +17,10 @@
 #include <boost/call_traits.hpp>

 #include <boost/type_traits/type_traits_test.hpp>
+
+// a way prevent warnings for unused variables
+template<class T> inline void unused_variable(const T&) {}
+
 //
 // struct contained models a type that contains a type (for example std::pair)
 // arrays are contained by value, and have to be treated as a special case:
@ -44,7 +48,7 @@ struct contained
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
   // pass value:
-   void call(param_type p){}
+   void call(param_type){}

 };

@ -69,7 +73,7 @@ struct contained<T[N]>
   // return by_ref:
   reference get() { return v_; }
   const_reference const_get()const { return v_; }
-   void call(param_type p){}
+   void call(param_type){}
 };
 #endif

@ -117,13 +121,14 @@ void call_traits_checker<T>::operator()(param_type p)
   assert(t == c.value());
   assert(t == c.get());
   assert(t == c.const_get());
-
+#ifndef __ICL
   //cout << "typeof contained<" << typeid(T).name() << ">::v_ is:           " << typeid(&contained<T>::v_).name() << endl;
   cout << "typeof contained<" << typeid(T).name() << ">::value() is:      " << typeid(&contained<T>::value).name() << endl;
   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
@ -155,10 +160,10 @@ struct call_traits_checker<T[N]>

 //
 // check_wrap:
-template <class T, class U>
-void check_wrap(const contained<T>& w, const U& u)
+template <class W, class U>
+void check_wrap(const W& w, const U& u)
 {
-   cout << "checking contained<" << typeid(T).name() << ">..." << endl;
+   cout << "checking " << typeid(W).name() << "..." << endl;
   assert(w.value() == u);
 }

@ -180,6 +185,12 @@ struct comparible_UDT
 {
   int i_;
   comparible_UDT() : i_(2){}
+   comparible_UDT(const comparible_UDT& other) : i_(other.i_){}
+   comparible_UDT& operator=(const comparible_UDT& other)
+   { 
+      i_ = other.i_;
+      return *this;
+   }
   bool operator == (const comparible_UDT& v){ return v.i_ == i_; }
 };

@ -192,25 +203,22 @@ int main(int argc, char *argv[ ])
   int i = 2;
   c2(i);
   int* pi = &i;
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
+   int a[2] = {1,2};
+#if (defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)) && !defined(__ICL)
   call_traits_checker<int*> c3;
   c3(pi);
   call_traits_checker<int&> c4;
   c4(i);
   call_traits_checker<const int&> c5;
   c5(i);
-#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   int a[2] = {1,2};
+#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__MWERKS__) && !defined(__SUNPRO_CC)
   call_traits_checker<int[2]> c6;
   c6(a);
 #endif
 #endif

   check_wrap(wrap(2), 2);
-   const char ca[4] = "abc";
-   // compiler can't deduce this for some reason:
-   //check_wrap(wrap(ca), ca);
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
   check_wrap(wrap(a), a);
   check_make_pair(test::make_pair(a, a), a, a);
 #endif
@ -237,7 +245,7 @@ int main(int argc, char *argv[ ])
   type_test(int&, boost::call_traits<int&>::reference)
   type_test(const int&, boost::call_traits<int&>::const_reference)
   type_test(int&, boost::call_traits<int&>::param_type)
-#if !(defined(__GNUC__) && (__GNUC__ < 3))
+#if !(defined(__GNUC__) && (__GNUC__ < 4))
   type_test(int&, boost::call_traits<cr_type>::value_type)
   type_test(int&, boost::call_traits<cr_type>::reference)
   type_test(const int&, boost::call_traits<cr_type>::const_reference)
@ -311,6 +319,19 @@ void call_traits_test<T, isarray>::assert_construct(typename call_traits_test<T,
   param_type p2(v);
   param_type p3(r);
   param_type p4(p);
+   
+   unused_variable(v2);
+   unused_variable(v3);
+   unused_variable(v4);
+   unused_variable(r2);
+   unused_variable(r3);
+   unused_variable(cr2);
+   unused_variable(cr3);
+   unused_variable(cr4);
+   unused_variable(cr5);
+   unused_variable(p2);
+   unused_variable(p3);
+   unused_variable(p4);
 }
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <typename T>
@ -347,6 +368,19 @@ void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>:
   param_type p2(v);
   param_type p3(r);
   param_type p4(p);
+   
+   unused_variable(v2);
+   unused_variable(v3);
+   unused_variable(v4);
+   unused_variable(v5);
+#ifndef __BORLANDC__
+   unused_variable(r2);
+   unused_variable(cr2);
+#endif
+   unused_variable(cr3);
+   unused_variable(p2);
+   unused_variable(p3);
+   unused_variable(p4);
 }
 #endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 //
@ -357,13 +391,21 @@ template struct call_traits_test<int*>;
 #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
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
 template struct call_traits_test<int[2], true>;
 #endif
 #endif

 #ifdef BOOST_MSVC
 unsigned int expected_failures = 10;
+#elif defined(__SUNPRO_CC)
+#if(__SUNPRO_CC <= 0x520)
+unsigned int expected_failures = 14;
+#elif(__SUNPRO_CC <= 0x530)
+unsigned int expected_failures = 13;
+#else
+unsigned int expected_failures = 6;
+#endif
 #elif defined(__BORLANDC__)
 unsigned int expected_failures = 2;
 #elif defined(__GNUC__)
@ -373,3 +415,6 @@ unsigned int expected_failures = 0;
 #endif


+
+
+
--- a/checked_delete_test.cpp
+++ b/checked_delete_test.cpp
@ -0,0 +1,31 @@
+//  Boost checked_delete test program  ---------------------------------------//
+
+//  (C) Copyright Beman Dawes 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
+//  21 May 01  Initial version (Beman Dawes)
+
+#include <boost/utility.hpp>  // for checked_delete
+
+//  This program demonstrates compiler errors when trying to delete an
+//  incomplete type.
+
+namespace
+{
+    class Incomplete;
+}
+
+int main()
+{
+    Incomplete * p;
+    boost::checked_delete(p);          // should cause compile time error
+    Incomplete ** pa;
+    boost::checked_array_delete(pa);   // should cause compile time error
+    return 0;
+}   // main
--- a/compressed_pair.htm
+++ b/compressed_pair.htm
@ -6,22 +6,23 @@ content="text/html; charset=iso-8859-1">
 <meta name="Template"
 content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
 <meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Header <boost/compressed_pair.hpp></title>
+<title>Header </title>
+<boost/compressed_pair.hpp>
 </head>

 <body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
 vlink="#800080">

 <h2><img src="../../c++boost.gif" width="276" height="86">Header
-&lt;<a href="../../boost/detail/call_traits.hpp">boost/compressed_pair.hpp</a>&gt;</h2>
+&lt;<a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a>&gt;</h2>

 <p>All of the contents of &lt;boost/compressed_pair.hpp&gt; are
 defined inside namespace boost.</p>

 <p>The class compressed pair is very similar to std::pair, but if
 either of the template arguments are empty classes, then the
-&quot;empty member optimisation&quot; is applied to compress the
-size of the pair.</p>
+&quot;empty base-class optimisation&quot; is applied to compress
+the size of the pair.</p>

 <pre>template &lt;class T1, class T2&gt;
 class compressed_pair
@ -41,6 +42,8 @@ public:
 	explicit compressed_pair(first_param_type x);
 	explicit compressed_pair(second_param_type y);

+	compressed_pair&amp; operator=(const compressed_pair&amp;);
+
 	first_reference       first();
 	first_const_reference first() const;

@ -61,17 +64,19 @@ constructor, and this constructor initialises both values in the
 pair to the passed value.</p>

 <p>Note that compressed_pair can not be instantiated if either of
-the template arguments is an enumerator type, unless there is
-compiler support for boost::is_enum, or if boost::is_enum is
-specialised for the enumerator type.</p>
+the template arguments is a union type, unless there is compiler
+support for boost::is_union, or if boost::is_union is specialised
+for the union type.</p>

-<p>Finally, compressed_pair requires compiler support for partial
-specialisation of class templates - without that support
-compressed_pair behaves just like std::pair.</p>
+<p>Finally, a word of caution for Visual C++ 6 users: if either
+argument is an empty type, then assigning to that member will
+produce memory corruption, unless the empty type has a &quot;do
+nothing&quot; assignment operator defined. This is due to a bug
+in the way VC6 generates implicit assignment operators.</p>

 <hr>

-<p>Revised 08 March 2000</p>
+<p>Revised 08 May 2001</p>

 <p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
 sell and distribute this document is granted provided this
@ -85,7 +90,8 @@ 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>
+discussion list at <a
+href="http://www.yahoogroups.com/list/boost">www.yahoogroups.com/list/boost</a>.</p>

 <p>&nbsp;</p>
 </body>
--- a/compressed_pair_test.cpp
+++ b/compressed_pair_test.cpp
@ -15,6 +15,8 @@

 #include <boost/compressed_pair.hpp>
 #include <boost/type_traits/type_traits_test.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>

 using namespace boost;

@ -54,101 +56,346 @@ struct non_empty2
   { return a.i == b.i; }
 };

-int main(int argc, char *argv[ ])
-{
-   compressed_pair<int, double> cp1(1, 1.3);
-   assert(cp1.first() == 1);
-   assert(cp1.second() == 1.3);
-   compressed_pair<int, double> cp1b(2, 2.3);
-   assert(cp1b.first() == 2);
-   assert(cp1b.second() == 2.3);
-   swap(cp1, cp1b);
-   assert(cp1b.first() == 1);
-   assert(cp1b.second() == 1.3);
-   assert(cp1.first() == 2);
-   assert(cp1.second() == 2.3);
-   compressed_pair<non_empty1, non_empty2> cp1c(non_empty1(9));
-   assert(cp1c.second() == non_empty2());
-   assert(cp1c.first() == non_empty1(9));
-   compressed_pair<non_empty1, non_empty2> cp1d(non_empty2(9));
-   assert(cp1d.second() == non_empty2(9));
-   assert(cp1d.first() == non_empty1());
-
-   compressed_pair<int, double> cp1e(cp1);
-
-   compressed_pair<empty_UDT, int> cp2(2);
-   assert(cp2.second() == 2);
-   compressed_pair<int, empty_UDT> cp3(1);
-   assert(cp3.first() ==1);
-   compressed_pair<empty_UDT, empty_UDT> cp4;
-   compressed_pair<empty_UDT, empty_POD_UDT> cp5;
-   compressed_pair<int, empty_UDT> cp9(empty_UDT());
-   compressed_pair<int, empty_UDT> cp10(1);
-   assert(cp10.first() == 1);
-#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   int i = 0;
-   compressed_pair<int&, int&> cp6(i,i);
-   assert(cp6.first() == i);
-   assert(cp6.second() == i);
-   assert(&cp6.first() == &i);
-   assert(&cp6.second() == &i);
-   compressed_pair<int, double[2]> cp7;
-   cp7.first();
-   double* pd = cp7.second();
+#ifdef __GNUC__
+using std::swap;
 #endif
-   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> >)))

-   return check_result(argc, argv);
+template <class T1, class T2>
+struct compressed_pair_tester
+{
+   // define the types we need:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   // define our test proc:
+   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
+{
+#ifndef __GNUC__
+   // gcc 2.90 can't cope with function scope using
+   // declarations, and generates an internal compiler error...
+   using std::swap;
+#endif
+   // default construct:
+   boost::compressed_pair<T1,T2> cp1;
+   // first param construct:
+   boost::compressed_pair<T1,T2> cp2(p1);
+   cp2.second() = p2;
+   BOOST_TEST(cp2.first() == p1);
+   BOOST_TEST(cp2.second() == p2);
+   // second param construct:
+   boost::compressed_pair<T1,T2> cp3(p2);
+   cp3.first() = p1;
+   BOOST_TEST(cp3.second() == p2);
+   BOOST_TEST(cp3.first() == p1);
+   // both param construct:
+   boost::compressed_pair<T1,T2> cp4(p1, p2);
+   BOOST_TEST(cp4.first() == p1);
+   BOOST_TEST(cp4.second() == p2);
+   boost::compressed_pair<T1,T2> cp5(p3, p4);
+   BOOST_TEST(cp5.first() == p3);
+   BOOST_TEST(cp5.second() == p4);
+   // check const members:
+   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
+   BOOST_TEST(cpr1.first() == p1);
+   BOOST_TEST(cpr1.second() == p2);
+
+   // copy construct:
+   boost::compressed_pair<T1,T2> cp6(cp4);
+   BOOST_TEST(cp6.first() == p1);
+   BOOST_TEST(cp6.second() == p2);
+   // assignment:
+   cp1 = cp4;
+   BOOST_TEST(cp1.first() == p1);
+   BOOST_TEST(cp1.second() == p2);
+   cp1 = cp5;
+   BOOST_TEST(cp1.first() == p3);
+   BOOST_TEST(cp1.second() == p4);
+   // swap:
+   cp4.swap(cp5);
+   BOOST_TEST(cp4.first() == p3);
+   BOOST_TEST(cp4.second() == p4);
+   BOOST_TEST(cp5.first() == p1);
+   BOOST_TEST(cp5.second() == p2);
+   swap(cp4,cp5);
+   BOOST_TEST(cp4.first() == p1);
+   BOOST_TEST(cp4.second() == p2);
+   BOOST_TEST(cp5.first() == p3);
+   BOOST_TEST(cp5.second() == p4);
 }

 //
-// instanciate some compressed pairs:
-#ifdef __MWERKS__
-template class compressed_pair<int, double>;
-template class compressed_pair<int, int>;
-template class compressed_pair<empty_UDT, int>;
-template class compressed_pair<int, empty_UDT>;
-template class compressed_pair<empty_UDT, empty_UDT>;
-template class compressed_pair<empty_UDT, empty_POD_UDT>;
-#else
-template class boost::compressed_pair<int, double>;
-template class boost::compressed_pair<int, int>;
-template class boost::compressed_pair<empty_UDT, int>;
-template class boost::compressed_pair<int, empty_UDT>;
-template class boost::compressed_pair<empty_UDT, empty_UDT>;
-template class boost::compressed_pair<empty_UDT, empty_POD_UDT>;
-#endif
+// tests for case where one or both 
+// parameters are reference types:
+//
+template <class T1, class T2>
+struct compressed_pair_reference_tester
+{
+   // define the types we need:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   // define our test proc:
+   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};

+template <class T1, class T2>
+void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
+{
+#ifndef __GNUC__
+   // gcc 2.90 can't cope with function scope using
+   // declarations, and generates an internal compiler error...
+   using std::swap;
+#endif
+   // both param construct:
+   boost::compressed_pair<T1,T2> cp4(p1, p2);
+   BOOST_TEST(cp4.first() == p1);
+   BOOST_TEST(cp4.second() == p2);
+   boost::compressed_pair<T1,T2> cp5(p3, p4);
+   BOOST_TEST(cp5.first() == p3);
+   BOOST_TEST(cp5.second() == p4);
+   // check const members:
+   const boost::compressed_pair<T1,T2>& cpr1 = cp4;
+   BOOST_TEST(cpr1.first() == p1);
+   BOOST_TEST(cpr1.second() == p2);
+
+   // copy construct:
+   boost::compressed_pair<T1,T2> cp6(cp4);
+   BOOST_TEST(cp6.first() == p1);
+   BOOST_TEST(cp6.second() == p2);
+   // assignment:
+   // VC6 bug:
+   // When second() is an empty class, VC6 performs the
+   // assignment by doing a memcpy - even though the empty
+   // class is really a zero sized base class, the result
+   // is that the memory of first() gets trampled over.
+   // Similar arguments apply to the case that first() is 
+   // an empty base class.
+   // Strangely the problem is dependent upon the compiler
+   // settings - some generate the problem others do not.
+   cp4.first() = p3;
+   cp4.second() = p4;
+   BOOST_TEST(cp4.first() == p3);
+   BOOST_TEST(cp4.second() == p4);
+}
+//
+// supplimentary tests for case where first arg only is a reference type:
+//
+template <class T1, class T2>
+struct compressed_pair_reference1_tester
+{
+   // define the types we need:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   // define our test proc:
+   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_reference1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#ifndef __MWERKS__
+   // first param construct:
+   boost::compressed_pair<T1,T2> cp2(p1);
+   cp2.second() = p2;
+   BOOST_TEST(cp2.first() == p1);
+   BOOST_TEST(cp2.second() == p2);
+#endif
+}
 //
-// 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&);
+// supplimentary tests for case where second arg only is a reference type:
 //
-// and then arrays:
-#ifndef __BORLANDC__
-template call_traits<int[2]>::reference compressed_pair<double, int[2]>::second();
+template <class T1, class T2>
+struct compressed_pair_reference2_tester
+{
+   // define the types we need:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   // define our test proc:
+   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_reference2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+   // second param construct:
+   boost::compressed_pair<T1,T2> cp3(p2);
+   cp3.first() = p1;
+   BOOST_TEST(cp3.second() == p2);
+   BOOST_TEST(cp3.first() == p1);
 #endif
-template call_traits<double>::reference compressed_pair<double, int[2]>::first();
-#if !(defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ < 95))
-template compressed_pair<double, int[2]>::compressed_pair(call_traits<double>::param_type);
-#endif
-template compressed_pair<double, int[2]>::compressed_pair();
-#endif // __MWERKS__
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+}
+
+//
+// tests for where one or the other parameter is an array:
+//
+template <class T1, class T2>
+struct compressed_pair_array1_tester
+{
+   // define the types we need:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   // define our test proc:
+   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_array1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
+  // default construct:
+   boost::compressed_pair<T1,T2> cp1;
+   // second param construct:
+   boost::compressed_pair<T1,T2> cp3(p2);
+   cp3.first()[0] = p1[0];
+   BOOST_TEST(cp3.second() == p2);
+   BOOST_TEST(cp3.first()[0] == p1[0]);
+   // check const members:
+   const boost::compressed_pair<T1,T2>& cpr1 = cp3;
+   BOOST_TEST(cpr1.first()[0] == p1[0]);
+   BOOST_TEST(cpr1.second() == p2);
+
+   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
+}
+
+template <class T1, class T2>
+struct compressed_pair_array2_tester
+{
+   // define the types we need:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   // define our test proc:
+   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_array2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
+   // default construct:
+   boost::compressed_pair<T1,T2> cp1;
+   // first param construct:
+   boost::compressed_pair<T1,T2> cp2(p1);
+   cp2.second()[0] = p2[0];
+   BOOST_TEST(cp2.first() == p1);
+   BOOST_TEST(cp2.second()[0] == p2[0]);
+   // check const members:
+   const boost::compressed_pair<T1,T2>& cpr1 = cp2;
+   BOOST_TEST(cpr1.first() == p1);
+   BOOST_TEST(cpr1.second()[0] == p2[0]);
+
+   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
+}
+
+template <class T1, class T2>
+struct compressed_pair_array_tester
+{
+   // define the types we need:
+   typedef T1                                                 first_type;
+   typedef T2                                                 second_type;
+   typedef typename call_traits<first_type>::param_type       first_param_type;
+   typedef typename call_traits<second_type>::param_type      second_param_type;
+   // define our test proc:
+   static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
+};
+
+template <class T1, class T2>
+void compressed_pair_array_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
+{
+   // default construct:
+   boost::compressed_pair<T1,T2> cp1;
+   cp1.first()[0] = p1[0];
+   cp1.second()[0] = p2[0];
+   BOOST_TEST(cp1.first()[0] == p1[0]);
+   BOOST_TEST(cp1.second()[0] == p2[0]);
+   // check const members:
+   const boost::compressed_pair<T1,T2>& cpr1 = cp1;
+   BOOST_TEST(cpr1.first()[0] == p1[0]);
+   BOOST_TEST(cpr1.second()[0] == p2[0]);
+
+   BOOST_TEST(sizeof(T1) == sizeof(cp1.first()));
+   BOOST_TEST(sizeof(T2) == sizeof(cp1.second()));
+}
+
+int test_main(int, char **)
+{
+   // declare some variables to pass to the tester:
+   non_empty1 ne1(2);
+   non_empty1 ne2(3);
+   non_empty2 ne3(4);
+   non_empty2 ne4(5);
+   empty_POD_UDT  e1;
+   empty_UDT      e2;
+
+   // T1 != T2, both non-empty
+   compressed_pair_tester<non_empty1,non_empty2>::test(ne1, ne3, ne2, ne4);
+   // T1 != T2, T2 empty
+   compressed_pair_tester<non_empty1,empty_POD_UDT>::test(ne1, e1, ne2, e1);
+   // T1 != T2, T1 empty
+   compressed_pair_tester<empty_POD_UDT,non_empty2>::test(e1, ne3, e1, ne4);
+   // T1 != T2, both empty
+   compressed_pair_tester<empty_POD_UDT,empty_UDT>::test(e1, e2, e1, e2);
+   // T1 == T2, both non-empty
+   compressed_pair_tester<non_empty1,non_empty1>::test(ne1, ne1, ne2, ne2);
+   // T1 == T2, both empty
+   compressed_pair_tester<empty_UDT,empty_UDT>::test(e2, e2, e2, e2);
+
+
+   // test references:
+
+   // T1 != T2, both non-empty
+   compressed_pair_reference_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
+   compressed_pair_reference_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
+   compressed_pair_reference1_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
+   compressed_pair_reference2_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
+   // T1 != T2, T2 empty
+   compressed_pair_reference_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
+   compressed_pair_reference1_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
+   // T1 != T2, T1 empty
+   compressed_pair_reference_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
+   compressed_pair_reference2_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
+   // T1 == T2, both non-empty
+   compressed_pair_reference_tester<non_empty1&,non_empty1&>::test(ne1, ne1, ne2, ne2);
+
+   // tests arrays:
+   non_empty1 nea1[2];
+   non_empty1 nea2[2];
+   non_empty2 nea3[2];
+   non_empty2 nea4[2];
+   nea1[0] = non_empty1(5);
+   nea2[0] = non_empty1(6);
+   nea3[0] = non_empty2(7);
+   nea4[0] = non_empty2(8);
+   
+   // T1 != T2, both non-empty
+   compressed_pair_array1_tester<non_empty1[2],non_empty2>::test(nea1, ne3, nea2, ne4);
+   compressed_pair_array2_tester<non_empty1,non_empty2[2]>::test(ne1, nea3, ne2, nea4);
+   compressed_pair_array_tester<non_empty1[2],non_empty2[2]>::test(nea1, nea3, nea2, nea4);
+   // T1 != T2, T2 empty
+   compressed_pair_array1_tester<non_empty1[2],empty_POD_UDT>::test(nea1, e1, nea2, e1);
+   // T1 != T2, T1 empty
+   compressed_pair_array2_tester<empty_POD_UDT,non_empty2[2]>::test(e1, nea3, e1, nea4);
+   // T1 == T2, both non-empty
+   compressed_pair_array_tester<non_empty1[2],non_empty1[2]>::test(nea1, nea1, nea2, nea2);
+   return 0;
+}
+

 unsigned int expected_failures = 0;




+
--- a/counting_iterator.htm
+++ b/counting_iterator.htm
@ -308,7 +308,7 @@ 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 -->26 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14386" --></p>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" --></p>
 <p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
 modify, sell and distribute this document is granted provided this copyright
 notice appears in all copies. This document is provided &quot;as is&quot;
--- a/counting_iterator_example.cpp
+++ b/counting_iterator_example.cpp
@ -42,12 +42,13 @@ int main(int, char*[])

  // Use indirect iterator to print out numbers by accessing
  // them through the array of pointers.
+#ifndef BOOST_MSVC
  std::cout << "indirectly printing out the numbers from 0 to " 
 	    << N << std::endl;
  std::copy(boost::make_indirect_iterator(pointers.begin()),
 	    boost::make_indirect_iterator(pointers.end()),
 	    std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;
-  
+#endif
  return 0;
 }
--- a/counting_iterator_test.cpp
+++ b/counting_iterator_test.cpp
@ -27,7 +27,7 @@
 #include <climits>
 #include <iterator>
 #include <stdlib.h>
-#include <boost/utility.hpp>
+#include <boost/tuple/tuple.hpp>
 #include <vector>
 #include <list>
 #include <cassert>
--- a/filter_iterator.htm
+++ b/filter_iterator.htm
@ -168,8 +168,8 @@ this parameter is the appropriate type.<br>

 The filter iterator adaptor (the type
 <tt>filter_iterator_generator<...>::type</tt>) may be a model of <a
-href="www.sgi.com/tech/stl/InputIterator.html">InputIterator</a> or <a
-href="www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</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.


@ -261,7 +261,7 @@ default).


 <hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->18 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14389" --></p>
+<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;
--- a/include/boost/detail/call_traits.hpp
+++ b/include/boost/detail/call_traits.hpp
@ -109,7 +109,7 @@ struct call_traits<T&const volatile>
   typedef T& param_type;  // hh removed const
 };
 #endif
-
+#ifndef __SUNPRO_CC
 template <typename T, std::size_t N>
 struct call_traits<T [N]>
 {
@ -135,6 +135,7 @@ public:
   typedef const array_type& const_reference;
   typedef const T* const param_type;
 };
+#endif

 }

--- a/include/boost/detail/compressed_pair.hpp
+++ b/include/boost/detail/compressed_pair.hpp
@ -32,6 +32,10 @@
 namespace boost
 {

+template <class T1, class T2>
+class compressed_pair;
+
+
 // compressed_pair

 namespace details
@ -104,10 +108,10 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_(x), second_(y) {}

-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_(x) {}

-      explicit compressed_pair_imp(second_param_type y)
+      compressed_pair_imp(second_param_type y)
         : second_(y) {}

      first_reference       first()       {return first_;}
@ -116,10 +120,10 @@ namespace details
      second_reference       second()       {return second_;}
      second_const_reference second() const {return second_;}

-      void swap(compressed_pair_imp& y)
+      void swap(::boost::compressed_pair<T1, T2>& y)
      {
-         cp_swap(first_, y.first_);
-         cp_swap(second_, y.second_);
+         cp_swap(first_, y.first());
+         cp_swap(second_, y.second());
      }
   private:
      first_type first_;
@ -147,10 +151,10 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_type(x), second_(y) {}

-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_type(x) {}

-      explicit compressed_pair_imp(second_param_type y)
+      compressed_pair_imp(second_param_type y)
         : second_(y) {}

      first_reference       first()       {return *this;}
@ -159,10 +163,10 @@ namespace details
      second_reference       second()       {return second_;}
      second_const_reference second() const {return second_;}

-      void swap(compressed_pair_imp& y)
+      void swap(::boost::compressed_pair<T1,T2>& y)
      {
         // no need to swap empty base class:
-         cp_swap(second_, y.second_);
+         cp_swap(second_, y.second());
      }
   private:
      second_type second_;
@ -189,10 +193,10 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : second_type(y), first_(x) {}

-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_(x) {}

-      explicit compressed_pair_imp(second_param_type y)
+      compressed_pair_imp(second_param_type y)
         : second_type(y) {}

      first_reference       first()       {return first_;}
@ -201,10 +205,10 @@ namespace details
      second_reference       second()       {return *this;}
      second_const_reference second() const {return *this;}

-      void swap(compressed_pair_imp& y)
+      void swap(::boost::compressed_pair<T1,T2>& y)
      {
         // no need to swap empty base class:
-         cp_swap(first_, y.first_);
+         cp_swap(first_, y.first());
      }

   private:
@ -233,10 +237,10 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_type(x), second_type(y) {}

-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_type(x) {}

-      explicit compressed_pair_imp(second_param_type y)
+      compressed_pair_imp(second_param_type y)
         : second_type(y) {}

      first_reference       first()       {return *this;}
@ -246,7 +250,7 @@ namespace details
      second_const_reference second() const {return *this;}
      //
      // no need to swap empty bases:
-      void swap(compressed_pair_imp&) {}
+      void swap(::boost::compressed_pair<T1,T2>&) {}
   };

   // JM
@ -272,7 +276,7 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type)
         : first_type(x) {}

-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_type(x) {}

      first_reference       first()       {return *this;}
@ -281,7 +285,7 @@ namespace details
      second_reference       second()       {return *this;}
      second_const_reference second() const {return *this;}

-      void swap(compressed_pair_imp&) {}
+      void swap(::boost::compressed_pair<T1,T2>&) {}
   private:
   };

@ -305,7 +309,7 @@ namespace details
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_(x), second_(y) {}

-      explicit compressed_pair_imp(first_param_type x)
+      compressed_pair_imp(first_param_type x)
         : first_(x), second_(x) {}

      first_reference       first()       {return first_;}
@ -314,10 +318,10 @@ namespace details
      second_reference       second()       {return second_;}
      second_const_reference second() const {return second_;}

-      void swap(compressed_pair_imp<T1, T2, 5>& y)
+      void swap(::boost::compressed_pair<T1, T2>& y)
      {
-         cp_swap(first_, y.first_);
-         cp_swap(second_, y.second_);
+         cp_swap(first_, y.first());
+         cp_swap(second_, y.second());
      }
   private:
      first_type first_;
@ -401,7 +405,10 @@ public:

            compressed_pair() : base() {}
            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
-   explicit compressed_pair(first_param_type x) : base(x) {}
+#if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530))
+   explicit 
+#endif
+      compressed_pair(first_param_type x) : base(x) {}

   first_reference       first()       {return base::first();}
   first_const_reference first() const {return base::first();}
@ -409,7 +416,7 @@ public:
   second_reference       second()       {return base::second();}
   second_const_reference second() const {return base::second();}

-   void swap(compressed_pair& y) { base::swap(y); }
+   void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
 };

 template <class T1, class T2>
--- a/include/boost/operators.hpp
+++ b/include/boost/operators.hpp
@ -1,20 +1,23 @@
 //  Boost operators.hpp header file  ----------------------------------------//

-//  (C) Copyright David Abrahams 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.
-
-//  (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.
+//  (C) Copyright David Abrahams, Jeremy Siek, and Daryle Walker 1999-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
+//  25 Jun 01 output_iterator_helper changes: removed default template 
+//            parameters, added support for self-proxying, additional 
+//            documentation and tests (Aleksey Gurtovoy)
+//  29 May 01 Added operator classes for << and >>.  Added input and output
+//            iterator helper classes.  Added classes to connect equality and
+//            relational operators.  Added classes for groups of related
+//            operators.  Reimplemented example operator and iterator helper
+//            classes in terms of the new groups.  (Daryle Walker, with help
+//            from Alexy Gurtovoy)
 //  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
@ -282,12 +285,190 @@ struct indexable : B
  }
 };

+//  More operator classes (contributed by Daryle Walker) --------------------//
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct left_shiftable2 : B
+{
+     friend T operator<<(T x, const U& y) { return x <<= y; }
+};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct left_shiftable1 : B
+{
+     friend T operator<<(T x, const T& y) { return x <<= y; }
+};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct right_shiftable2 : B
+{
+     friend T operator>>(T x, const U& y) { return x >>= y; }
+};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct right_shiftable1 : B
+{
+     friend T operator>>(T x, const T& y) { return x >>= y; }
+};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct equivalent2 : B
+{
+  friend bool operator==(const T& x, const U& y)
+  {
+    return !(x < y) && !(x > y);
+  }
+};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct equivalent1 : B
+{
+  friend bool operator==(const T&x, const T&y)
+  {
+    return !(x < y) && !(y < x);
+  }
+};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct partially_ordered2 : B
+{
+  friend bool operator<=(const T& x, const U& y)
+    { return (x < y) || (x == y); }
+  friend bool operator>=(const T& x, const U& y)
+    { return (x > y) || (x == y); }
+  friend bool operator>(const U& x, const T& y)
+    { return y < x; }
+  friend bool operator<(const U& x, const T& y)
+    { return y > x; }
+  friend bool operator<=(const U& x, const T& y)
+    { return (y > x) || (y == x); }
+  friend bool operator>=(const U& x, const T& y)
+    { return (y < x) || (y == x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct partially_ordered1 : B
+{
+  friend bool operator>(const T& x, const T& y)
+    { return y < x; }
+  friend bool operator<=(const T& x, const T& y)
+    { return (x < y) || (x == y); }
+  friend bool operator>=(const T& x, const T& y)
+    { return (y < x) || (x == y); }
+};
+
+//  Combined operator classes (contributed by Daryle Walker) ----------------//
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct totally_ordered2
+    : less_than_comparable2<T, U
+    , equality_comparable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct totally_ordered1
+    : less_than_comparable1<T
+    , equality_comparable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct additive2
+    : addable2<T, U
+    , subtractable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct additive1
+    : addable1<T
+    , subtractable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct multiplicative2
+    : multipliable2<T, U
+    , dividable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct multiplicative1
+    : multipliable1<T
+    , dividable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct integer_multiplicative2
+    : multiplicative2<T, U
+    , modable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct integer_multiplicative1
+    : multiplicative1<T
+    , modable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct arithmetic2
+    : additive2<T, U
+    , multiplicative2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct arithmetic1
+    : additive1<T
+    , multiplicative1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct integer_arithmetic2
+    : additive2<T, U
+    , integer_multiplicative2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct integer_arithmetic1
+    : additive1<T
+    , integer_multiplicative1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct bitwise2
+    : xorable2<T, U
+    , andable2<T, U
+    , orable2<T, U, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct bitwise1
+    : xorable1<T
+    , andable1<T
+    , orable1<T, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct unit_steppable
+    : incrementable<T
+    , decrementable<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct shiftable2
+    : left_shiftable2<T, U
+    , right_shiftable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct shiftable1
+    : left_shiftable1<T
+    , right_shiftable1<T, B
+      > > {};
+
 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
 } // namespace boost
 #endif // BOOST_NO_OPERATORS_IN_NAMESPACE


-// BOOST_IMPORT_TEMPLATE1/BOOST_IMPORT_TEMPLATE2 -
+// BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE3 -
 //
 // When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
 // operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
@ -295,12 +476,31 @@ struct indexable : B
 // two-argument forms. Note that these macros expect to be invoked from within
 // boost.

-#if defined(BOOST_NO_OPERATORS_IN_NAMESPACE)
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE

-#  if defined(BOOST_NO_USING_TEMPLATE)
+  // The template is already in boost so we have nothing to do.
+# define BOOST_IMPORT_TEMPLATE3(template_name)
+# define BOOST_IMPORT_TEMPLATE2(template_name)
+# define BOOST_IMPORT_TEMPLATE1(template_name)
+
+#else // BOOST_NO_OPERATORS_IN_NAMESPACE
+
+#  ifndef BOOST_NO_USING_TEMPLATE
+
+     // Bring the names in with a using-declaration
+     // to avoid stressing the compiler.
+#    define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name;
+#    define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
+#    define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
+
+#  else
+
+     // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
+     // from working, we are forced to use inheritance for that compiler.
+#    define BOOST_IMPORT_TEMPLATE3(template_name)                                 \
+     template <class T, class U, class V, class B = ::boost::detail::empty_base>  \
+     struct template_name : ::template_name<T, U, V, B> {};

-     // Because a Borland C++ 5.5 bug prevents a using declaration from working,
-     // we are forced to use inheritance for that compiler.
 #    define BOOST_IMPORT_TEMPLATE2(template_name)                              \
     template <class T, class U, class B = ::boost::detail::empty_base>        \
     struct template_name : ::template_name<T, U, B> {};
@ -309,21 +509,8 @@ struct indexable : B
     template <class T, class B = ::boost::detail::empty_base>                 \
     struct template_name : ::template_name<T, B> {};

-#  else
-
-     // Otherwise, bring the names in with a using-declaration to avoid
-     // stressing the compiler
-#    define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
-#    define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
-
 #  endif // BOOST_NO_USING_TEMPLATE

-#else // !BOOST_NO_OPERATORS_IN_NAMESPACE
-
-  // The template is already in boost so we have nothing to do.
-# define BOOST_IMPORT_TEMPLATE2(template_name)
-# define BOOST_IMPORT_TEMPLATE1(template_name)
-
 #endif // BOOST_NO_OPERATORS_IN_NAMESPACE

 //
@ -332,7 +519,7 @@ struct indexable : B
 // the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
 // neccessary.
 //
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

 // is_chained_base<> - a traits class used to distinguish whether an operator
 // template argument is being used for base class chaining, or is specifying a
@ -355,6 +542,15 @@ template<class T> struct is_chained_base {

 } // namespace boost

+// Import a 3-type-argument operator template into boost (if neccessary) and
+// provide a specialization of 'is_chained_base<>' for it.
+# define BOOST_OPERATOR_TEMPLATE3(template_name3)                     \
+  BOOST_IMPORT_TEMPLATE3(template_name3)                              \
+  template<class T, class U, class V, class B>                        \
+  struct is_chained_base< ::boost::template_name3<T, U, V, B> > {     \
+    typedef ::boost::detail::true_t value;                            \
+  };
+
 // Import a 2-type-argument operator template into boost (if neccessary) and
 // provide a specialization of 'is_chained_base<>' for it.
 # define BOOST_OPERATOR_TEMPLATE2(template_name2)                  \
@ -414,6 +610,8 @@ BOOST_OPERATOR_TEMPLATE1(template_name##1)

 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

+#  define BOOST_OPERATOR_TEMPLATE3(template_name3) \
+        BOOST_IMPORT_TEMPLATE3(template_name3)
 #  define BOOST_OPERATOR_TEMPLATE2(template_name2) \
        BOOST_IMPORT_TEMPLATE2(template_name2)
 #  define BOOST_OPERATOR_TEMPLATE1(template_name1) \
@ -442,47 +640,41 @@ BOOST_OPERATOR_TEMPLATE(orable)

 BOOST_OPERATOR_TEMPLATE1(incrementable)
 BOOST_OPERATOR_TEMPLATE1(decrementable)
+
 BOOST_OPERATOR_TEMPLATE2(dereferenceable)
+BOOST_OPERATOR_TEMPLATE3(indexable)

-// indexable doesn't follow the patterns above (it has 4 template arguments), so
-// we just write out the compiler hacks explicitly.
-#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
-# ifdef BOOST_NO_USING_TEMPLATE
-   template <class T, class I, class R, class B = ::boost::detail::empty_base>
-   struct indexable : ::indexable<T,I,R,B> {};
-# else
-   using ::indexable;
-# endif
-#endif
+BOOST_OPERATOR_TEMPLATE(left_shiftable)
+BOOST_OPERATOR_TEMPLATE(right_shiftable)
+BOOST_OPERATOR_TEMPLATE(equivalent)
+BOOST_OPERATOR_TEMPLATE(partially_ordered)

-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T, class I, class R, class B>
-struct is_chained_base< ::boost::indexable<T, I, R, B> > {
-  typedef ::boost::detail::true_t operator_template_type;
-};
-#endif
+BOOST_OPERATOR_TEMPLATE(totally_ordered)
+BOOST_OPERATOR_TEMPLATE(additive)
+BOOST_OPERATOR_TEMPLATE(multiplicative)
+BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
+BOOST_OPERATOR_TEMPLATE(arithmetic)
+BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
+BOOST_OPERATOR_TEMPLATE(bitwise)
+BOOST_OPERATOR_TEMPLATE1(unit_steppable)
+BOOST_OPERATOR_TEMPLATE(shiftable)

 #undef BOOST_OPERATOR_TEMPLATE
+#undef BOOST_OPERATOR_TEMPLATE3
 #undef BOOST_OPERATOR_TEMPLATE2
 #undef BOOST_OPERATOR_TEMPLATE1
 #undef BOOST_IMPORT_TEMPLATE1
 #undef BOOST_IMPORT_TEMPLATE2
+#undef BOOST_IMPORT_TEMPLATE3

 // The following 'operators' classes can only be used portably if the derived class
 // declares ALL of the required member operators.
 template <class T, class U>
 struct operators2
-    : less_than_comparable2<T,U
-    , equality_comparable2<T,U
-    , addable2<T,U
-    , subtractable2<T,U
-    , multipliable2<T,U
-    , dividable2<T,U
-    , modable2<T,U
-    , orable2<T,U
-    , andable2<T,U
-    , xorable2<T,U
-      > > > > > > > > > > {};
+    : totally_ordered2<T,U
+    , integer_arithmetic2<T,U
+    , bitwise2<T,U
+      > > > {};

 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T, class U = T>
@ -492,31 +684,47 @@ template <class T> struct operators<T, T>
 #else
 template <class T> struct operators
 #endif
-    : less_than_comparable<T
-    , equality_comparable<T
-    , addable<T
-    , subtractable<T
-    , multipliable<T
-    , dividable<T
-    , modable<T
-    , orable<T
-    , andable<T
-    , xorable<T
-    , incrementable<T
-    , decrementable<T
-      > > > > > > > > > > > > {};
+    : totally_ordered<T
+    , integer_arithmetic<T
+    , bitwise<T
+    , unit_steppable<T
+      > > > > {};

 //  Iterator helper classes (contributed by Jeremy Siek) -------------------//
+//  (Input and output iterator helpers contributed by Daryle Walker) -------//
+//  (Changed to use combined operator classes by Daryle Walker) ------------//
+template <class T,
+          class V,
+          class D = std::ptrdiff_t,
+          class P = V const *,
+          class R = V const &>
+struct input_iterator_helper
+  : equality_comparable1<T
+  , incrementable<T
+  , dereferenceable<T, P
+  , boost::iterator<std::input_iterator_tag, V, D, P, R
+    > > > > {};
+
+template<class Derived>
+struct output_iterator_helper
+  : boost::incrementable<Derived
+  , boost::iterator<std::output_iterator_tag, void, void, void, void
+  > >
+{
+  Derived& operator*()  { return static_cast<Derived&>(*this); }
+  Derived& operator++() { return static_cast<Derived&>(*this); }
+};
+
 template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
 struct forward_iterator_helper
-  : equality_comparable<T
+  : equality_comparable1<T
  , incrementable<T
-  , dereferenceable<T,P
-  , boost::iterator<std::forward_iterator_tag,V,D,P,R
+  , dereferenceable<T, P
+  , boost::iterator<std::forward_iterator_tag, V, D, P, R
    > > > > {};

 template <class T,
@ -525,12 +733,11 @@ template <class T,
          class P = V*,
          class R = V&>
 struct bidirectional_iterator_helper
-  : equality_comparable<T
-  , incrementable<T
-  , decrementable<T
-  , dereferenceable<T,P
-  , boost::iterator<std::bidirectional_iterator_tag,V,D,P,R
-    > > > > > {};
+  : equality_comparable1<T
+  , unit_steppable<T
+  , dereferenceable<T, P
+  , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
+    > > > > {};

 template <class T,
          class V, 
@ -538,22 +745,17 @@ template <class T,
          class P = V*,
          class R = V&>
 struct random_access_iterator_helper
-  : equality_comparable<T
-  , less_than_comparable<T
-  , incrementable<T
-  , decrementable<T
-  , dereferenceable<T,P
-  , addable2<T,D
-  , subtractable2<T,D
-  , indexable<T,D,R
-  , boost::iterator<std::random_access_iterator_tag,V,D,P,R
-    > > > > > > > > >
+  : totally_ordered1<T
+  , unit_steppable<T
+  , dereferenceable<T, P
+  , additive2<T, D
+  , indexable<T, D, R
+  , boost::iterator<std::random_access_iterator_tag, V, D, P, R
+    > > > > > >
 {
-#ifndef __BORLANDC__
  friend D requires_difference_operator(const T& x, const T& y) {
    return x - y;
  }
-#endif
 }; // random_access_iterator_helper

 } // namespace boost
--- a/include/boost/ref.hpp
+++ b/include/boost/ref.hpp
@ -0,0 +1,55 @@
+#ifndef BOOST_REF_HPP_INCLUDED
+#define BOOST_REF_HPP_INCLUDED
+
+#if _MSC_VER >= 1020
+#pragma once
+#endif
+
+//
+//  ref.hpp - ref/cref, useful helper functions
+//
+//  Version 1.00.0003 (2001-08-22)
+//
+//  Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
+//
+//  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/libs/bind/ref.html for documentation.
+//
+
+namespace boost
+{
+
+template<class T> class reference_wrapper
+{ 
+public:
+
+    explicit reference_wrapper(T & t): t_(t) {}
+
+    operator T & () const { return t_; }
+
+    T & get() const { return t_; }
+
+private:
+
+    T & t_;
+
+    reference_wrapper & operator= (reference_wrapper const &);
+};
+
+template<class T> inline reference_wrapper<T> ref(T & t)
+{ 
+    return reference_wrapper<T>(t);
+}
+
+template<class T> inline reference_wrapper<T const> cref(T const & t)
+{
+    return reference_wrapper<T const>(t);
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_REF_HPP_INCLUDED
--- a/include/boost/utility.hpp
+++ b/include/boost/utility.hpp
@ -10,24 +10,39 @@

 //  Classes appear in alphabetical order

-//  Revision History
-//  26 Jan 00  protected noncopyable destructor added (Miki Jovanovic)
-//  10 Dec 99  next() and prior() templates added (Dave Abrahams)
-//  30 Aug 99  moved cast templates to cast.hpp (Beman Dawes)
-//   3 Aug 99  cast templates added
-//  20 Jul 99  name changed to utility.hpp 
-//   9 Jun 99  protected noncopyable default ctor
-//   2 Jun 99  Initial Version. Class noncopyable only contents (Dave Abrahams)
-
 #ifndef BOOST_UTILITY_HPP
 #define BOOST_UTILITY_HPP

-#include <boost/config.hpp>
-#include <cstddef>            // for size_t
-#include <utility>            // for std::pair
+#include <boost/config.hpp>        // broken compiler workarounds
+#include <boost/static_assert.hpp>
+
+// certain headers are part of the <utility.hpp> interface
+#include <boost/utility/base_from_member.hpp>  
+ 
+#include <cstddef>                 // for size_t
+#include <utility>                 // for std::pair

 namespace boost
 {
+//  checked_delete() and checked_array_delete()  -----------------------------//
+
+    // verify that types are complete for increased safety
+
+    template< typename T >
+    inline void checked_delete(T * x)
+    {
+        BOOST_STATIC_ASSERT( sizeof(T) != 0 ); // assert type complete at point
+                                               // of instantiation
+        delete x;
+    }
+
+    template< typename T >
+    inline void checked_array_delete(T  * x)
+    {
+        BOOST_STATIC_ASSERT( sizeof(T) != 0 ); // assert type complete at point
+                                               // of instantiation
+        delete [] x;
+    }

 //  next() and prior() template functions  -----------------------------------//

@ -41,10 +56,10 @@ namespace boost
    //  Contributed by Dave Abrahams

    template <class T>
-    T next(T x) { return ++x; }
+    inline T next(T x) { return ++x; }

    template <class T>
-    T prior(T x) { return --x; }
+    inline T prior(T x) { return --x; }


 //  class noncopyable  -------------------------------------------------------//
@ -64,31 +79,6 @@ namespace boost
        const noncopyable& operator=( const noncopyable& );
    }; // noncopyable

-//  class tied  -------------------------------------------------------//
-
-    // A helper for conveniently assigning the two values from a pair
-    // into separate variables. The idea for this comes from Jaakko J<>rvi's
-    // Binder/Lambda Library.
-
-    // Constributed by Jeremy Siek
-
-    template <class A, class B>
-    class tied {
-    public:
-      inline tied(A& a, B& b) : _a(a), _b(b) { }
-      template <class U, class V>
-      inline tied& operator=(const std::pair<U,V>& p) {
-        _a = p.first;
-        _b = p.second;
-        return *this;
-      }
-    protected:
-      A& _a;
-      B& _b;
-    };
-
-    template <class A, class B>
-    inline tied<A,B> tie(A& a, B& b) { return tied<A,B>(a, b); }

 } // namespace boost

--- a/include/boost/utility/base_from_member.hpp
+++ b/include/boost/utility/base_from_member.hpp
@ -0,0 +1,59 @@
+//  boost utility/base_from_member.hpp header file  --------------------------//
+
+//  (C) Copyright Daryle Walker 2001.  Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies.  This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+#ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
+#define BOOST_UTILITY_BASE_FROM_MEMBER_HPP
+
+#include <boost/utility_fwd.hpp>  // required for parameter defaults
+
+
+namespace boost
+{
+
+//  Base-from-member class template  -----------------------------------------//
+
+// Helper to initialize a base object so a derived class can use this
+// object in the initialization of another base class.  Used by
+// Dietmar Kuehl from ideas by Ron Klatcho to solve the problem of a
+// base class needing to be initialized by a member.
+
+// Contributed by Daryle Walker
+
+template < typename MemberType, int UniqueID >
+class base_from_member
+{
+protected:
+    MemberType  member;
+
+    explicit  base_from_member()
+        : member()
+        {}
+
+    template< typename T1 >
+    explicit base_from_member( T1 x1 )
+        : member( x1 )
+        {}
+
+    template< typename T1, typename T2 >
+    base_from_member( T1 x1, T2 x2 )
+        : member( x1, x2 )
+        {}
+
+    template< typename T1, typename T2, typename T3 >
+    base_from_member( T1 x1, T2 x2, T3 x3 )
+        : member( x1, x2, x3 ) 
+        {}
+
+};  // boost::base_from_member
+
+}  // namespace boost
+
+
+#endif  // BOOST_UTILITY_BASE_FROM_MEMBER_HPP
--- a/include/boost/utility_fwd.hpp
+++ b/include/boost/utility_fwd.hpp
@ -0,0 +1,34 @@
+//  Boost utility_fwd.hpp header file  ---------------------------------------//
+
+//  (C) Copyright boost.org 2001.  Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies.  This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+#ifndef BOOST_UTILITY_FWD_HPP
+#define BOOST_UTILITY_FWD_HPP
+
+
+namespace boost
+{
+
+
+//  From <boost/utility/base_from_member.hpp>  -------------------------------//
+
+template < typename MemberType, int UniqueID = 0 >
+    class base_from_member;
+
+
+//  From <boost/utility.hpp>  ------------------------------------------------//
+
+class noncopyable;
+
+// Also has a few function templates
+
+}  // namespace boost
+
+
+#endif  // BOOST_UTILITY_FWD_HPP
--- a/indirect_iterator.htm
+++ b/indirect_iterator.htm
@ -203,10 +203,10 @@ explicit indirect_iterator_generator::type(const BaseIterator&amp; it)

    <blockquote>
 <pre>
-template &lt;class BaseIterator,
-          class Value, class Pointer, class Reference,
-          class ConstPointer, class ConstReference&gt;
-class indirect_iterator_pair_generator
+  template &lt;class BaseIterator,
+            class Value, class Reference, class ConstReference, 
+            class Category, class Pointer, class ConstPointer&gt;
+  struct indirect_iterator_pair_generator;
 {
 public:
  typedef <tt><a href=
@ -292,13 +292,6 @@ b,c,d,e,f,g,h,
        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> 

@ -307,6 +300,19 @@ b,c,d,e,f,g,h,
        <tt>operator*()</tt>.<br>
         <b>Default:</b> <tt>const Value&amp;</tt> 

+      <tr>
+        <td><tt>Category</tt> 
+        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseIterator&gt;::iterator_category</tt> 
+
+      <tr>
+        <td><tt>Pointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting <tt>iterator</tt>, and
+        in particular, the result type of its <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> <tt>Value*</tt> 
+
      <tr>
        <td><tt>ConstPointer</tt> 

@ -314,11 +320,6 @@ b,c,d,e,f,g,h,
        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>
@ -422,7 +423,7 @@ a,b,c,d,e,f,g,
    <hr>

    <p>Revised 
-    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->18 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14389" -->
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->18 Sep 2001<!--webbot bot="Timestamp" endspan i-checksum="14941" -->


    <p>&copy; Copyright Jeremy Siek and David Abrahams 2001. Permission to
--- a/indirect_iterator_example.cpp
+++ b/indirect_iterator_example.cpp
@ -29,13 +29,12 @@ int main(int, char*[])

  // Example of using indirect_iterator_pair_generator

-  typedef boost::indirect_iterator_pair_generator<char**,
-    char, char*, char&, const char*, const char&> PairGen;
+  typedef boost::indirect_iterator_pair_generator<char**, 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];
+  for (int j = 0; j < N; ++j)
+    pointers_to_mutable_chars[j] = &mutable_characters[j];

  PairGen::iterator mutable_indirect_first(pointers_to_mutable_chars),
    mutable_indirect_last(pointers_to_mutable_chars + N);
@ -52,10 +51,12 @@ int main(int, char*[])
  
  // Example of using make_indirect_iterator()

+#ifndef BOOST_MSVC
  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
 	    boost::make_indirect_iterator(pointers_to_chars + N),
 	    std::ostream_iterator<char>(std::cout, ","));
  std::cout << std::endl;
+#endif
  
  return 0;
 }
--- a/indirect_iterator_test.cpp
+++ b/indirect_iterator_test.cpp
@ -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_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.
+
+// 04 Nov 2001   Jeremy Siek
+//     Updated with respect to new named parameter interface.
+// 08 Mar 2001   Jeremy Siek
+//     Initial checkin.
+
+#include <boost/iterator_adaptors.hpp>
+#include <boost/pending/iterator_tests.hpp>
+#include <boost/static_assert.hpp>
+
+class bar { };
+void foo(bar) { }
+
+int
+main()
+{
+  using boost::dummyT;
+  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+		     dummyT(3), dummyT(4), dummyT(5) };
+  typedef boost::iterator_adaptor<dummyT*, 
+    boost::default_iterator_policies, dummyT> my_iter;
+  my_iter mi(array);
+
+  {
+    typedef boost::iterator_adaptor<my_iter, boost::default_iterator_policies,
+      boost::reference_is<dummyT>,
+      boost::iterator_category_is<std::input_iterator_tag> > iter_type;
+
+    BOOST_STATIC_ASSERT((boost::is_same<iter_type::iterator_category*,
+       std::input_iterator_tag*>::value));
+
+    BOOST_STATIC_ASSERT(( ! boost::is_convertible<iter_type::iterator_category*,
+       std::forward_iterator_tag*>::value));
+
+    iter_type i(mi);
+    boost::input_iterator_test(i, dummyT(0), dummyT(1));
+  }
+  {
+    typedef boost::iterator_adaptor<dummyT*,
+      boost::default_iterator_policies,
+      boost::value_type_is<dummyT>,
+      boost::reference_is<const dummyT&>,
+      boost::pointer_is<const dummyT*> ,
+      boost::iterator_category_is<std::forward_iterator_tag>,
+      boost::difference_type_is<std::ptrdiff_t> > adaptor_type;
+
+    adaptor_type i(array);
+
+    boost::input_iterator_test(i, dummyT(0), dummyT(1));
+    int zero = 0;
+    if (zero) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+
+  return 0;
+}
--- a/iterator_adaptor_examples.cpp
+++ b/iterator_adaptor_examples.cpp
@ -7,7 +7,7 @@
 #include <functional>
 #include <algorithm>
 #include <iostream>
-#include <boost/pending/iterator_adaptors.hpp>
+#include <boost/iterator_adaptors.hpp>
 #include <boost/pending/integer_range.hpp>

 int
@ -21,8 +21,7 @@ main(int, char*[])
  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>
+  typedef boost::transform_iterator_generator<Function, int* 
  >::type doubling_iterator;

  doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
--- a/iterator_adaptor_test.cpp
+++ b/iterator_adaptor_test.cpp
@ -1,4 +1,4 @@
-//  Demonstrate and test boost/operators.hpp on std::iterators  -------------//
+//  Test boost/iterator_adaptors.hpp

 //  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
 //  sell and distribute this software is granted provided this
@ -9,6 +9,10 @@
 //  See http://www.boost.org for most recent version including documentation.

 //  Revision History
+//  04 Nov 01 Updated with respect to change in named parameters.
+//            (Jeremy Siek)
+//  08 Mar 01 Moved indirect and transform tests to separate files.
+//            (Jeremy Siek)
 //  19 Feb 01 Take adavantage of improved iterator_traits to do more tests
 //            on MSVC. Hack around an MSVC-with-STLport internal compiler
 //            error. (David Abrahams)
@ -50,37 +54,17 @@
 #include <boost/pending/iterator_tests.hpp>
 #include <boost/pending/integer_range.hpp>
 #include <boost/concept_archetype.hpp>
+#include <boost/type_traits/same_traits.hpp>
 #include <stdlib.h>
 #include <vector>
 #include <deque>
 #include <set>
+#include <list>

 struct my_iterator_tag : public std::random_access_iterator_tag { };

 using boost::dummyT;

-struct my_iter_traits {
-  typedef dummyT value_type;
-  typedef dummyT* pointer;
-  typedef dummyT& reference;
-  typedef my_iterator_tag iterator_category;
-  typedef std::ptrdiff_t difference_type;
-};
-
-struct my_const_iter_traits {
-  typedef dummyT value_type;
-  typedef const dummyT* pointer;
-  typedef const dummyT& reference;
-  typedef my_iterator_tag iterator_category;
-  typedef std::ptrdiff_t difference_type;
-};
-
-typedef boost::iterator_adaptor<dummyT*, 
-  boost::default_iterator_policies, dummyT> my_iterator;
-
-typedef boost::iterator_adaptor<const dummyT*, 
-  boost::default_iterator_policies, const dummyT> const_my_iterator;
-

 struct mult_functor {
  typedef int result_type;
@ -117,77 +101,9 @@ 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;
+template <class T> struct foo;

-    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);
-
-    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    
-}
+void blah(int) { }

 int
 main()
@ -197,78 +113,69 @@ main()
  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);
+  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::default_iterator_policies,
+       boost::iterator_adaptor<int*, boost::default_iterator_policies>,
       boost::iterator<std::random_access_iterator_tag, int, std::ptrdiff_t,
                      int*, int&>
      > >();

-  // Test the iterator_adaptor
+  // Test the named parameters
  {
-    my_iterator i(array);
-    boost::random_access_iterator_test(i, N, array);
-    
-    const_my_iterator j(array);
-    boost::random_access_iterator_test(j, N, array);
-    boost::const_nonconst_iterator_test(i, ++j);
+    // Test computation of defaults
+    typedef boost::iterator_adaptor<int*, boost::default_iterator_policies,
+      boost::value_type_is<int> > Iter1;
+    // don't use std::iterator_traits here to avoid VC++ problems
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::value_type, int>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, int&>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, int*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::difference_type, std::ptrdiff_t>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::iterator_category, std::random_access_iterator_tag>::value));
+  }
+  {  
+    // Test computation of default when the Value is const
+    typedef boost::iterator_adaptor<std::list<int>::iterator,
+      boost::default_iterator_policies,
+      boost::value_type_is<const int> > Iter1;
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::value_type, int>::value));
+#if defined(__BORLANDC__) || defined(BOOST_MSVC)
+    // We currently don't know how to workaround this bug.
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, int&>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, int*>::value));
+#else
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, const int&>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, const int*>::value));
+#endif
  }
-
-  // Test 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]);
+    // Test with no defaults
+    typedef boost::iterator_adaptor<int*, boost::default_iterator_policies,
+      boost::reference_is<long>,
+      boost::pointer_is<float*>,
+      boost::value_type_is<char>,
+      boost::iterator_category_is<std::input_iterator_tag>,
+      boost::difference_type_is<int>
+    > Iter1;
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::value_type, char>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, long>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, float*>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::difference_type, int>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::iterator_category, std::input_iterator_tag>::value));
  }
  
-  // Test indirect_iterator_generator
+  // Test the iterator_adaptor
  {
-    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::iterator_adaptor<dummyT*, boost::default_iterator_policies, dummyT> i(array);
    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::iterator_adaptor<const dummyT*, boost::default_iterator_policies, const dummyT> j(array);
    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();
  }

  // Test projection_iterator_pair_generator
@ -318,7 +225,7 @@ main()

    typedef boost::reverse_iterator_generator<const dummyT*
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-        , const dummyT
+      , dummyT, const dummyT&, const dummyT
 #endif
      >::type const_reverse_iterator;
    
@ -376,23 +283,33 @@ main()

  // Test filter iterator
  {
-    // Using typedefs for filter_gen::type and filter_gen::policies_type
-    // confused Borland terribly.
+    // 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*
+    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
@ -433,12 +350,24 @@ main()
  // check operator-> with a forward iterator
  {
    boost::forward_iterator_archetype<dummyT> forward_iter;
+#if defined(__BORLANDC__)
    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
      boost::default_iterator_policies,
      dummyT, const dummyT&, const dummyT*, 
      std::forward_iterator_tag, std::ptrdiff_t> adaptor_type;
+#else
+    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      boost::reference_is<const dummyT&>,
+      boost::pointer_is<const dummyT*> ,
+      boost::iterator_category_is<std::forward_iterator_tag>,
+      boost::value_type_is<dummyT>,
+      boost::difference_type_is<std::ptrdiff_t>
+    > adaptor_type;
+#endif
    adaptor_type i(forward_iter);
-    if (0) // don't do this, just make sure it compiles
+    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
@ -449,10 +378,10 @@ main()
      dummyT, const dummyT&, const dummyT*, 
      std::input_iterator_tag, std::ptrdiff_t> adaptor_type;
    adaptor_type i(input_iter);
-    if (0) // don't do this, just make sure it compiles
+    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
@ -26,6 +26,37 @@
    "../../more/generic_programming.html#adaptors">adaptors</a> which apply
    specific useful behaviors to arbitrary base iterators.

+    <h2>Backward Compatibility Note</h2>
+
+    <p>The library's interface has changed since it was first released, breaking
+    backward compatibility:
+
+    <ol>
+
+    <li><a href="#policies">Policies classes</a> now operate on instances of the
+    whole <tt>iterator_adaptor</tt> object, rather than just operating on the
+    <tt>Base</tt> object. This change not only gives the policies class access
+    to both members of a pair of interacting iterators, but also eliminates the
+    need for the ugly <tt>type&lt;Reference&gt;</tt> and
+    <tt>type&lt;Difference&gt;</tt> parameters to various policy functions.
+
+    <li>The <a href="#named_template_parameters">Named Template Parameter</a>
+    interface has been made simpler, easier to use, and compatible with more
+    compilers.
+
+    </ol>
+
+    <h2>Other Documentation</h2>
+
+    <p><a href="iterator_adaptors.pdf">``Policy Adaptors and the Boost Iterator
+    Adaptor Library''</a> is a technical paper describing this library and the
+    powerful design pattern on which it is based. It was presented at the <a
+    href="http://www.oonumerics.org/tmpw01">C++ Template Workshop</a> at OOPSLA
+    2001; the slides from the talk are available <a
+    href="iterator_adaptors.ppt">here</a>. Please note that while the slides
+    incorporate the minor interface changes described in the previous section,
+    the paper does not.
+
    <h2>Table of Contents</h2>

    <ul>
@ -44,6 +75,8 @@

              <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>
@ -63,7 +96,7 @@
            </ul>

          <li>
-            Specialized Iterator Adaptors 
+            <a name="specialized_adaptors">Specialized Iterator Adaptors</a> 

            <ul>
              <li><a href="indirect_iterator.htm">Indirect Iterator Adaptor</a>
@ -91,7 +124,7 @@
       <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
+    <p><b><a href="../../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
@ -100,7 +133,7 @@
    <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
+     <b><a href="../../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>, 
@ -129,11 +162,11 @@
    <p><tt>iterator_adaptor</tt> is declared like this:
 <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;
+    class ValueOrNamedParam = typename std::iterator_traits&lt;Base&gt;::value_type,
+    class ReferenceOrNamedParam = <i>...(see below)</i>,
+    class PointerOrNamedParam = <i>...(see below)</i>,
+    class CategoryOrNamedParam = typename std::iterator_traits&lt;Base&gt;::iterator_category,
+    class DistanceOrNamedParam = typename std::iterator_traits&lt;Base&gt;::difference_type&gt;
 struct iterator_adaptor;
 </pre>

@ -168,7 +201,8 @@ struct iterator_adaptor;
        <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>
+        "#1">[1]</a>. If the <tt>value_type</tt> you wish to use is an abstract
+        base class see note <a href="#5">[5]</a>.<br>
         <b>Default:</b>
        <tt>std::iterator_traits&lt;BaseType&gt;::value_type</tt> <a href=
        "#2">[2]</a>
@ -180,7 +214,7 @@ struct iterator_adaptor;
        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.
+        <tt>std::iterator_traits&lt;BaseType&gt;::reference</tt> is used. <a href="#7">[7]</a>

      <tr>
        <td><tt>Pointer</tt> 
@ -188,7 +222,7 @@ struct iterator_adaptor;
        <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>.
+        otherwise <tt>std::iterator_traits&lt;BaseType&gt;::pointer</tt>. <a href="#7">[7]</a>

      <tr>
        <td><tt>Category</tt> 
@ -203,27 +237,70 @@ struct iterator_adaptor;
        <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>NamedParam</tt>
+
+         <td>A named template parameter (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 a set of named template parameters. The following
+    classes are provided for specifying the parameters. Any of these
+    classes can be used for any of the last five template parameters
+    of <tt>iterator_adaptor</tt>.
+    <blockquote>
+<pre>
+template &lt;class Value&gt; struct value_type_is;
+template &lt;class Reference&gt; struct reference_is;
+template &lt;class Pointer&gt; struct pointer_is;
+template &lt;class Distance&gt; struct difference_type_is;
+template &lt;class Category&gt; struct iterator_category_is;
+</pre>
+    </blockquote>
+
+    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>
+typedef iterator_adaptor&lt;foo_iterator, foo_policies,
+  reference_is&lt;foo&gt;, iterator_category_is&lt;std::input_iterator_tag&gt;
+  &gt; MyIterator;
+</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 iterator adaptor, supplying the core
-    iterator operations that will determine how your new adaptor class will
-    behave. The <tt>iterator_adaptor</tt> template defines all of the operators
-    required of a <a href=
+    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>. Your <tt>Policies</tt> class must implement three, four, or
-    seven of the core iterator operations below depending on the iterator
-    categories you want it to support.<br>
+    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>: 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
+        <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>
@ -236,13 +313,13 @@ struct iterator_adaptor;
        <th>Required for Iterator Categories

      <tr>
-        <td><tt>dereference</tt> 
+        <td><tt>initialize</tt>

-        <td>returns an element of the iterator's <tt>reference</tt> type
-        
-        <td><tt>*p</tt>, <tt>p[n]</tt>
+        <td>optionally modify base iterator during iterator construction

-        <td rowspan="3"><a href=
+        <td>constructors
+
+        <td rowspan="4"><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
@ -251,6 +328,15 @@ struct iterator_adaptor;
        <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
        Access</a> 

+	  
+      <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>
+
+
      <tr>
        <td><tt>equal</tt> 

@ -330,43 +416,48 @@ struct iterator_adaptor;
 <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; }
+    // Some of these members were defined static, but Borland got confused
+    // and thought they were non-const. Also, Sun C++ does not like static
+    // function templates.

-  template &lt;class BaseType&gt;
-  static void increment(BaseType&amp; x)
-    { ++x; }
+    template &lt;class Base&gt;
+    void initialize(Base&amp;)
+        { }

-  template &lt;class BaseType1, class BaseType2&gt;
-  bool equal(BaseType1&amp; x, BaseType2&amp; y) const
-    { return x == y; }
+    template &lt;class IteratorAdaptor&gt;
+    typename IteratorAdaptor::reference dereference(const IteratorAdaptor&amp; x) const
+        { return *x.base(); }

-  template &lt;class BaseType&gt;
-  static void decrement(BaseType&amp; x)
-    { --x; }
+    template &lt;class IteratorAdaptor&gt;
+    void increment(IteratorAdaptor&amp; x)
+        { ++x.base(); }

-  template &lt;class BaseType, class DifferenceType&gt;
-  static void advance(BaseType&amp; x, DifferenceType n)
-    { x += n; }
+    template &lt;class IteratorAdaptor&gt;
+    void decrement(IteratorAdaptor&amp; x)
+        { --x.base(); }

-  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 IteratorAdaptor, class DifferenceType&gt;
+    void advance(IteratorAdaptor&amp; x, DifferenceType n)
+        { x.base() += n; }

-  template &lt;class BaseType1, class BaseType2&gt;
-  bool less(BaseType1&amp; x, BaseType2&amp; y) const
-    { return x &lt; y; }
+    template &lt;class IteratorAdaptor1, class IteratorAdaptor2&gt;
+    typename IteratorAdaptor1::difference_type
+    distance(const IteratorAdaptor1&amp; x, const IteratorAdaptor2&amp; y) const
+        { return y.base() - x.base(); }
+
+    template &lt;class IteratorAdaptor1, class IteratorAdaptor2&gt;
+    bool equal(const IteratorAdaptor1&amp; x, const IteratorAdaptor2&amp; y) const
+        { return x.base() == y.base(); }
 };
-</pre>
-    </blockquote>
+</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 may achieve the same sort of reusability.
+    <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=
@ -391,7 +482,7 @@ struct <a name="default_iterator_policies">default_iterator_policies</a>
         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
+         This constructor allows for conversion from mutable 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>.
@ -423,34 +514,31 @@ struct <a name="default_iterator_policies">default_iterator_policies</a>

    <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
+    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>
+    dereference the base iterator and apply the function object. 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
-  {
+<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); }
+        : m_f(f) { }
+    
+    template &lt;class IteratorAdaptor&gt;
+    typename IteratorAdaptor::reference
+    dereference(const IteratorAdaptor&amp; iter) const
+        { return m_f(*iter.base()); }

    AdaptableUnaryFunction m_f;
-  };
-</pre>
-    </blockquote>
+};
+
+</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
@ -486,7 +574,7 @@ public:

    <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
+    for the transform iterator. Our object generator makes it more
    convenient to create a transform iterator.<br>
    <br>

@ -522,10 +610,10 @@ 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::cout &lt;&lt; &quot;multiplying the array by 2:&quot; &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::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
  std::cout &lt;&lt; std::endl;
  return 0;
 }
@ -678,10 +766,10 @@ struct iterator_adaptor
    iterator_adaptor(
        const iterator_adaptor&lt;B,Policies,V,R,P,Category,Distance&gt;&amp;);

-    reference operator*() const;
+    reference operator*() const; <a href="#6">[6]</a>
    <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>
+    <i>value_type</i> operator[](difference_type n) const; <a href="#3">[4]</a>, <a href="#6">[6]</a>

    iterator_adaptor&amp; operator++();
    iterator_adaptor&amp; operator++(int);
@ -725,12 +813,12 @@ bool operator==(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;,
    <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.
+    <tt>const</tt>-ness of <tt>Value</tt> allows you to easily make a constant
+    iterator 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
@ -754,10 +842,60 @@ bool operator==(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;,
    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>.
+
+    <p><a name="5">[5]</a>
+    The <tt>value_type</tt> of an iterator may not be
+    an abstract base class, however many common uses of iterators
+    never need the <tt>value_type</tt>, only the <tt>reference</tt> type.
+    If you wish to create such an iterator adaptor, use a dummy
+    type such as <tt>char</tt> for the <tt>Value</tt> parameter,
+    and use a reference to your abstract base class for
+    the <tt>Reference</tt> parameter. Note that such an iterator
+    does not fulfill the C++ standards requirements for a
+    <a href= "http://www.sgi.com/tech/stl/ForwardIterator.html">
+    Forward Iterator</a>, so you will need to use a less restrictive
+    iterator category such as <tt>std::input_iterator_tag</tt>.
+
+    <p><a name="6">[6]</a>
+    There is a common misconception that an iterator should have two
+    versions of <tt>operator*</tt> and of <tt>operator[]</tt>, one
+    version that is a <tt>const</tt> member function and one version
+    that is non-<tt>const</tt>. Perhaps the source of this
+    misconception is that containers typically have const and
+    non-const versions of many of their member functions.  Iterators,
+    however, are different. A particular iterator type can be either
+    <i>mutable</i> or <i>constant</i> (but not both).  One can assign
+    to and change the object pointed to by a mutable iterator whereas a
+    constant iterator returns constant objects when dereferenced. Whether
+    the iterator object itself is <tt>const</tt> has nothing to do with
+    whether the iterator is mutable or constant.  This is analogous to
+    the way built-in pointer types behave.  For example, one can
+    modify objects pointed to by a <tt>const</tt> pointer
+<pre>
+    int* const x = new int;
+    int i = 3;
+    *x = i;
+</pre>
+    but one cannot modify objects pointed to by a pointer
+    to <tt>const</tt>
+<pre>
+    int const* x = new int;
+    int i = 3;
+    *x = i;
+</pre>
+
+    <p><a name="7">[7]</a>
+    If you are using a compiler that does not have a version of
+    <tt>std::iterator_traits</tt> that works for pointers (i.e., if your
+    compiler does not support partial specialization) then if the
+    <tt>Base</tt> type is a const pointer, then the correct defaults
+    for the <tt>reference</tt> and <tt>pointer</tt> types can not be
+    deduced. You must specify these types explicitly.
+
    <hr>

    <p>Revised 
-    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->27 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14388" -->
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->18 Sep 2001<!--webbot bot="Timestamp" endspan i-checksum="14941" -->


    <p>&copy; Copyright Dave Abrahams and Jeremy Siek 2001. Permission to copy,
@ -768,7 +906,7 @@ bool operator==(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;,

 </body>

-    <!--  LocalWords:  HTML html charset alt gif abrahams htm const
+    <!--  LocalWords:  HTML html charset alt gif abrahams htm const iterator
        incrementable david abrahams
         -->
     
@ -784,6 +922,7 @@ bool operator==(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;,
    <!--  LocalWords:  iostream hpp sizeof InputIterator constness ConstIterator
         David Abrahams
         -->
-</body>
+<!--  LocalWords:  Iterators dereferenced
+ -->
 </html>

--- a/iterator_adaptors.pdf
+++ b/iterator_adaptors.pdf
--- a/iterator_adaptors.ppt
+++ b/iterator_adaptors.ppt
--- a/iterator_traits_test.cpp
+++ b/iterator_traits_test.cpp
@ -7,6 +7,7 @@
 //  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)
@ -153,7 +154,7 @@ input_iterator_test<std::istream_iterator<int>, int, std::ptrdiff_t, int*, int&,
 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) && !defined(__SGI_STL_PORT)
+#elif defined(BOOST_MSVC_STD_ITERATOR)
 non_pointer_test<std::ostream_iterator<int>,
    int, void, void, void, std::output_iterator_tag>
        ostream_iterator_test;
--- a/iterators_test.cpp
+++ b/iterators_test.cpp
@ -9,16 +9,29 @@
 //  See http://www.boost.org for most recent version including documentation.

 //  Revision History
+//  29 May 01 Factored implementation, added comparison tests, use Test Tools
+//            library (Daryle Walker)
 //  12 Dec 99 Initial version with iterator operators (Jeremy Siek)

-#include <string>
-#include <iostream>
-using namespace std;
+#define  BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>  // for main

-#include <boost/operators.hpp>
-using namespace boost;
+#include <boost/config.hpp>     // for BOOST_STATIC_CONSTANT
+#include <boost/cstdlib.hpp>    // for boost::exit_success
+#include <boost/operators.hpp>  // for boost::random_access_iterator_helper
+
+#include <cstddef>    // for std::ptrdiff_t, std::size_t
+#include <cstring>    // for std::strcmp
+#include <iostream>   // for std::cout (std::endl, ends, and flush indirectly)
+#include <string>     // for std::string
+#include <strstream>  // for std::ostrstream
+
+# ifdef BOOST_NO_STDC_NAMESPACE
+    namespace std { using ::strcmp; }
+# endif


+// Iterator test class
 template <class T, class R, class P>
 struct test_iter
  : public boost::random_access_iterator_helper<
@ -29,7 +42,7 @@ struct test_iter
  typedef std::ptrdiff_t Distance;

 public:
-  test_iter(T* i) : _i(i) { }
+  explicit test_iter(T* i =0) : _i(i) { }
  test_iter(const self& x) : _i(x._i) { }
  self& operator=(const self& x) { _i = x._i; return *this; }
  Reference operator*() const { return *_i; }
@ -43,127 +56,280 @@ public:
    return x._i - y._i; 
  }
 protected:
-  T* _i;
+  P _i;
 };

-
-int
-main()
+// Iterator operator testing classes
+class test_opr_base
 {
-  string array[] = { "apple", "orange", "pear", "peach", "grape", "plum"  };
-  {
-    test_iter<string,string&,string*> i = array, 
-      ie = array + sizeof(array)/sizeof(string);
+protected:
+    // Test data and types
+    BOOST_STATIC_CONSTANT( std::size_t, fruit_length = 6u );
+    BOOST_STATIC_CONSTANT( std::size_t, scratch_length = 40u );

-    // Tests for all of the operators added by random_access_iterator_helper
+    typedef std::string  fruit_array_type[ fruit_length ];
+    typedef char         scratch_array_type[ scratch_length ];

-    // test i++
-    while (i != ie)
-      cout << *i++ << " ";
-    cout << endl;
-    i = array;
+    static  fruit_array_type    fruit;
+    static  scratch_array_type  scratch;

-    // test i--
-    while (ie != i) {
-      ie--;
-      cout << *ie << " ";
-    }
-    cout << endl;
-    ie = array + sizeof(array)/sizeof(string);
+};  // test_opr_base

-    // test i->m
-    while (i != ie) {
-      cout << i->size() << " ";
-      ++i;
-    }
-    cout << endl;
-    i = array;
+template <typename T, typename R = T&, typename P = T*>
+class test_opr
+    : public test_opr_base
+{
+    typedef test_opr<T, R, P>  self_type;

-    // test i + n
-    while (i < ie) {
-      cout << *i << " ";
-      i = i + 2;
-    }
-    cout << endl;
-    i = array;
+public:
+    // Types
+    typedef T  value_type;
+    typedef R  reference;
+    typedef P  pointer;

-    // test n + i
-    while (i < ie) {
-      cout << *i << " ";
-      i = ptrdiff_t(2) + i;
-    }
-    cout << endl;
-    i = array;
+    typedef test_iter<T, R, P>  iter_type;

-    // test i - n
-    while (ie > i) {
-      ie = ie - 2;
-      cout << *ie << " ";
-    }
-    cout << endl;
-    ie = array + sizeof(array)/sizeof(string);
+    // Test controller
+    static  void  master_test( char const name[] );

-    // test i[n]
-    for (std::size_t j = 0; j < sizeof(array)/sizeof(string); ++j)
-      cout << i[j] << " ";
-    cout << endl;
-  }
-  {
-    test_iter<string, const string&, const string*> i = array, 
-      ie = array + sizeof(array)/sizeof(string);
+private:
+    // Test data
+    static  iter_type const  fruit_begin, fruit_end;

-    // Tests for all of the operators added by random_access_iterator_helper
+    // Test parts
+    static  void  post_increment_test();
+    static  void  post_decrement_test();
+    static  void  indirect_referral_test();
+    static  void  offset_addition_test();
+    static  void  reverse_offset_addition_test();
+    static  void  offset_subtraction_test();
+    static  void  comparison_test();
+    static  void  indexing_test();

-    // test i++
-    while (i != ie)
-      cout << *i++ << " ";
-    cout << endl;
-    i = array;
+};  // test_opr

-    // test i--
-    while (ie != i) {
-      ie--;
-      cout << *ie << " ";
-    }
-    cout << endl;
-    ie = array + sizeof(array)/sizeof(string);

-    // test i->m
-    while (i != ie) {
-      cout << i->size() << " ";
-      ++i;
-    }
-    cout << endl;
-    i = array;
+// Class-static data definitions
+test_opr_base::fruit_array_type
+ test_opr_base::fruit = { "apple", "orange", "pear", "peach", "grape", "plum" };

-    // test i + n
-    while (i < ie) {
-      cout << *i << " ";
-      i = i + 2;
-    }
-    cout << endl;
-    i = array;
+test_opr_base::scratch_array_type
+ test_opr_base::scratch = "";

-    // test n + i
-    while (i < ie) {
-      cout << *i << " ";
-      i = ptrdiff_t(2) + i;
-    }
-    cout << endl;
-    i = array;
+template <typename T, typename R, typename P>
+typename test_opr<T, R, P>::iter_type const
+ test_opr<T, R, P>::fruit_begin( fruit );

-    // test i - n
-    while (ie > i) {
-      ie = ie - 2;
-      cout << *ie << " ";
-    }
-    cout << endl;
-    ie = array + sizeof(array)/sizeof(string);
+template <typename T, typename R, typename P>
+typename test_opr<T, R, P>::iter_type const
+ test_opr<T, R, P>::fruit_end( fruit + fruit_length );

-    // test i[n]
-    for (std::size_t j = 0; j < sizeof(array)/sizeof(string); ++j)
-      cout << i[j] << " ";
-    cout << endl;
-  }
-  return 0;
+
+// Main testing function
+int
+test_main( int , char * [] )
+{
+    using std::string;
+
+    typedef test_opr<string, string &, string *>              test1_type;
+    typedef test_opr<string, string const &, string const *>  test2_type;
+
+    test1_type::master_test( "non-const string" );
+    test2_type::master_test( "const string" );
+
+    return boost::exit_success;
+}
+
+// Tests for all of the operators added by random_access_iterator_helper
+template <typename T, typename R, typename P>
+void
+test_opr<T, R, P>::master_test
+(
+    char const  name[]
+)
+{
+    std::cout << "Doing test run for " << name << '.' << std::endl;
+
+    post_increment_test();
+    post_decrement_test();
+    indirect_referral_test();
+    offset_addition_test();
+    reverse_offset_addition_test();
+    offset_subtraction_test();
+    comparison_test();
+    indexing_test();
+}
+
+// Test post-increment
+template <typename T, typename R, typename P>
+void
+test_opr<T, R, P>::post_increment_test
+(
+)
+{
+    std::cout << "\tDoing post-increment test." << std::endl;
+
+    std::ostrstream  oss( scratch, scratch_length );
+    for ( iter_type i = fruit_begin ; i != fruit_end ; )
+    {
+        oss << *i++ << ' ';
+    }
+
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "apple orange pear peach grape plum ")
+     == 0 );
+}
+
+// Test post-decrement
+template <typename T, typename R, typename P>
+void
+test_opr<T, R, P>::post_decrement_test
+(
+)
+{
+    std::cout << "\tDoing post-decrement test." << std::endl;
+
+    std::ostrstream  oss( scratch, scratch_length );
+    for ( iter_type i = fruit_end ; i != fruit_begin ; )
+    {
+        i--;
+        oss << *i << ' ';
+    }
+
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "plum grape peach pear orange apple ")
+     == 0 );
+}
+
+// Test indirect structure referral
+template <typename T, typename R, typename P>
+void
+test_opr<T, R, P>::indirect_referral_test
+(
+)
+{
+    std::cout << "\tDoing indirect reference test." << std::endl;
+
+    std::ostrstream  oss( scratch, scratch_length );
+    for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
+    {
+        oss << i->size() << ' ';
+    }
+
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "5 6 4 5 5 4 ") == 0 );
+}
+
+// Test offset addition
+template <typename T, typename R, typename P>
+void
+test_opr<T, R, P>::offset_addition_test
+(
+)
+{
+    std::cout << "\tDoing offset addition test." << std::endl;
+
+    std::ptrdiff_t const  two = 2;
+    std::ostrstream       oss( scratch, scratch_length );
+    for ( iter_type i = fruit_begin ; i != fruit_end ; i = i + two )
+    {
+        oss << *i << ' ';
+    }
+
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "apple pear grape ") == 0 );
+}
+
+// Test offset addition, in reverse order
+template <typename T, typename R, typename P>
+void
+test_opr<T, R, P>::reverse_offset_addition_test
+(
+)
+{
+    std::cout << "\tDoing reverse offset addition test." << std::endl;
+
+    std::ptrdiff_t const  two = 2;
+    std::ostrstream       oss( scratch, scratch_length );
+    for ( iter_type i = fruit_begin ; i != fruit_end ; i = two + i )
+    {
+        oss << *i << ' ';
+    }
+
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "apple pear grape ") == 0 );
+}
+
+// Test offset subtraction
+template <typename T, typename R, typename P>
+void
+test_opr<T, R, P>::offset_subtraction_test
+(
+)
+{
+    std::cout << "\tDoing offset subtraction test." << std::endl;
+
+    std::ptrdiff_t const  two = 2;
+    std::ostrstream       oss( scratch, scratch_length );
+    for ( iter_type i = fruit_end ; fruit_begin < i ; )
+    {
+        i = i - two;
+        if ( (fruit_begin < i) || (fruit_begin == i) )
+        {
+            oss << *i << ' ';
+        }
+    }
+
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "grape pear apple ") == 0 );
+}
+
+// Test comparisons
+template <typename T, typename R, typename P>
+void
+test_opr<T, R, P>::comparison_test
+(
+)
+{
+    using std::cout;
+    using std::ptrdiff_t;
+
+    cout << "\tDoing comparison tests.\n\t\tPass:";
+
+    for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
+    {
+        ptrdiff_t const  i_offset = i - fruit_begin;
+
+        cout << ' ' << *i << std::flush;
+        for ( iter_type j = fruit_begin ; j != fruit_end ; ++j )
+        {
+            ptrdiff_t const  j_offset = j - fruit_begin;
+
+            BOOST_TEST( (i != j) == (i_offset != j_offset) );
+            BOOST_TEST( (i > j) == (i_offset > j_offset) );
+            BOOST_TEST( (i <= j) == (i_offset <= j_offset) );
+            BOOST_TEST( (i >= j) == (i_offset >= j_offset) );
+        }
+    }
+    cout << std::endl;
+}
+
+// Test indexing
+template <typename T, typename R, typename P>
+void
+test_opr<T, R, P>::indexing_test
+(
+)
+{
+    std::cout << "\tDoing indexing test." << std::endl;
+
+    std::ostrstream  oss( scratch, scratch_length );
+    for ( std::size_t k = 0u ; k < fruit_length ; ++k )
+    {
+        oss << fruit_begin[ k ] << ' ';
+    }
+
+    oss << std::ends;
+    BOOST_TEST( std::strcmp(oss.str(), "apple orange pear peach grape plum ")
+     == 0 );
 }
--- a/numeric_traits_test.cpp
+++ b/numeric_traits_test.cpp
@ -7,6 +7,7 @@
 //  See http://www.boost.org for most recent version including documentation.

 //  Revision History
+//  1  Apr 2001 Fixes for ICL; use BOOST_STATIC_CONSTANT
 //  11 Feb 2001 Fixes for Borland (David Abrahams)
 //  23 Jan 2001 Added test for wchar_t (David Abrahams)
 //  23 Jan 2001 Now statically selecting a test for signed numbers to avoid
@ -30,13 +31,6 @@
 # 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> --
 //
@ -53,8 +47,8 @@ template <unsigned size> struct complement; // forward
 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);
+    BOOST_STATIC_CONSTANT(Number, max = complement<size>::template traits<Number>::max);
+    BOOST_STATIC_CONSTANT(Number, min = complement<size>::template traits<Number>::min);
 };

 template <unsigned size>
@ -67,11 +61,11 @@ struct complement
        // indirection through complement_traits_aux neccessary to keep MSVC happy
        typedef complement_traits_aux<Number, size - 1> prev;
     public:
-        DECLARE_CLASS_CONST(Number, max =
+        BOOST_STATIC_CONSTANT(Number, max =
                            Number(Number(prev::max) << CHAR_BIT)
                            + Number(UCHAR_MAX));
        
-        DECLARE_CLASS_CONST(Number, min = Number(Number(prev::min) << CHAR_BIT));
+        BOOST_STATIC_CONSTANT(Number, min = Number(Number(prev::min) << CHAR_BIT));
    };
 };

@ -85,8 +79,8 @@ template <> struct complement_base<false>
    template <class Number>
    struct values
    {
-        DECLARE_CLASS_CONST(Number, min = 0);
-        DECLARE_CLASS_CONST(Number, max = UCHAR_MAX);
+        BOOST_STATIC_CONSTANT(Number, min = 0);
+        BOOST_STATIC_CONSTANT(Number, max = UCHAR_MAX);
    };
 };

@ -95,8 +89,8 @@ template <> struct complement_base<true>
    template <class Number>
    struct values
    {
-        DECLARE_CLASS_CONST(Number, min = SCHAR_MIN);
-        DECLARE_CLASS_CONST(Number, max = SCHAR_MAX);
+        BOOST_STATIC_CONSTANT(Number, min = SCHAR_MIN);
+        BOOST_STATIC_CONSTANT(Number, max = SCHAR_MAX);
    };
 };

@ -107,10 +101,10 @@ 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 =
+        BOOST_STATIC_CONSTANT(bool, is_signed = boost::detail::is_signed<Number>::value);
+        BOOST_STATIC_CONSTANT(Number, min =
                            complement_base<is_signed>::template values<Number>::min);
-        DECLARE_CLASS_CONST(Number, max =
+        BOOST_STATIC_CONSTANT(Number, max =
                            complement_base<is_signed>::template values<Number>::max);
    };
 };
@ -121,8 +115,8 @@ struct complement<1>
 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));
+    BOOST_STATIC_CONSTANT(Number, max = (complement_traits_aux<Number, sizeof(Number)>::max));
+    BOOST_STATIC_CONSTANT(Number, min = (complement_traits_aux<Number, sizeof(Number)>::min));
 };

 // =================================================================================
@ -151,9 +145,9 @@ template <> struct stream_as<signed char>  {
    typedef unsigned char t1; typedef unsigned t2;
 };

-#if defined(BOOST_MSVC) // No intmax streaming built-in
+#if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in

-// On this platform, __int64 and __uint64 get streamed as strings
+// With this library implementation, __int64 and __uint64 get streamed as strings
 template <> struct stream_as<boost::uintmax_t> {
    typedef std::string t1;
    typedef std::string t2;
@ -174,7 +168,7 @@ template <class T> struct promote
    }
 };

-#if defined(BOOST_MSVC) // No intmax streaming built-in
+#if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in

 // On this platform, stream them as long/unsigned long if they fit.
 // Otherwise, write a string.
@ -380,7 +374,7 @@ int main()
    test<unsigned int>();
    test<long>();
    test<unsigned long>();
-#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
+#if defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T)
    test<long long>();
    test<unsigned long long>();
 #elif defined(BOOST_MSVC)
--- a/operators.htm
+++ b/operators.htm
--- a/operators_test.cpp
+++ b/operators_test.cpp
@ -8,18 +8,26 @@
 //  See http://www.boost.org for most recent version including documentation.

 //  Revision History
+//  20 May 01 Output progress messages.  Added tests for new operator
+//            templates.  Updated random number generator.  Changed tests to
+//            use Boost Test Tools library.  (Daryle Walker)
 //  04 Jun 00 Added regression test for a bug I found (David Abrahams)
 //  17 Jun 00 Fix for broken compilers (Aleksey Gurtovoy)
 //  ?? ??? 00 Major update to randomly test all one- and two- argument forms by
-//            wrapping integral types and comparing the results of operations to
-//            the results for the raw types (David Abrahams)
+//            wrapping integral types and comparing the results of operations
+//            to the results for the raw types (David Abrahams)
 //  12 Dec 99 Minor update, output confirmation message.
 //  15 Nov 99 Initial version

-#include <boost/operators.hpp>
-#include <cassert>
-#include <iostream>
-#include <boost/min_rand.hpp>
+#define BOOST_INCLUDE_MAIN
+
+#include <boost/config.hpp>                      // for BOOST_MSVC
+#include <boost/cstdlib.hpp>                     // for boost::exit_success
+#include <boost/operators.hpp>                   // for the tested items
+#include <boost/random/linear_congruential.hpp>  // for boost::minstd_rand
+#include <boost/test/test_tools.hpp>             // for main
+
+#include <iostream>  // for std::cout (std::endl indirectly)


 namespace
@ -28,14 +36,18 @@ namespace
    int true_value(int x) { return x; }
    long true_value(long x) { return x; }
    signed char true_value(signed char x) { return x; }
+    short true_value(short x) { return x; }
    unsigned int true_value(unsigned int x) { return x; }
    unsigned long true_value(unsigned long x) { return x; }
    unsigned char true_value(unsigned char x) { return x; }
+    unsigned short true_value(unsigned short x) { return x; }

-    // The use of operators<> here tended to obscure interactions with certain
-    // compiler bugs
+    // The use of operators<> here tended to obscure
+    // interactions with certain compiler bugs
    template <class T>
-    class Wrapped1 : boost::operators<Wrapped1<T> >
+    class Wrapped1
+        : boost::operators<Wrapped1<T> >
+        , boost::shiftable<Wrapped1<T> >
    {
    public:
        explicit Wrapped1( T v = T() ) : _value(v) {}
@ -60,6 +72,10 @@ namespace
          { _value &= x._value; return *this; }
        Wrapped1& operator^=(const Wrapped1& x)
          { _value ^= x._value; return *this; }
+        Wrapped1& operator<<=(const Wrapped1& x)
+          { _value <<= x._value; return *this; }
+        Wrapped1& operator>>=(const Wrapped1& x)
+          { _value >>= x._value; return *this; }
        Wrapped1& operator++()               { ++_value; return *this; }
        Wrapped1& operator--()               { --_value; return *this; }
        
@ -70,9 +86,11 @@ namespace
    T true_value(Wrapped1<T> x) { return x.value(); }    

    template <class T, class U>
-    class Wrapped2 :
-        boost::operators<Wrapped2<T, U> >,
-        boost::operators2<Wrapped2<T, U>, U>
+    class Wrapped2
+        : boost::operators<Wrapped2<T, U> >
+        , boost::operators2<Wrapped2<T, U>, U>
+        , boost::shiftable1<Wrapped2<T, U>
+        , boost::shiftable2<Wrapped2<T, U>, U > >
    {
    public:
        explicit Wrapped2( T v = T() ) : _value(v) {}
@ -97,6 +115,10 @@ namespace
          { _value &= x._value; return *this; }
        Wrapped2& operator^=(const Wrapped2& x)
          { _value ^= x._value; return *this; }
+        Wrapped2& operator<<=(const Wrapped2& x)
+          { _value <<= x._value; return *this; }
+        Wrapped2& operator>>=(const Wrapped2& x)
+          { _value >>= x._value; return *this; }
        Wrapped2& operator++()                { ++_value; return *this; }
        Wrapped2& operator--()                { --_value; return *this; }
         
@ -111,6 +133,8 @@ namespace
        Wrapped2& operator|=(U u) { _value |= u; return *this; }
        Wrapped2& operator&=(U u) { _value &= u; return *this; }
        Wrapped2& operator^=(U u) { _value ^= u; return *this; }
+        Wrapped2& operator<<=(U u) { _value <<= u; return *this; }
+        Wrapped2& operator>>=(U u) { _value >>= u; return *this; }

    private:
        T _value;
@ -118,203 +142,268 @@ namespace
    template <class T, class U>
    T true_value(Wrapped2<T,U> x) { return x.value(); }
    
+    template <class T>
+    class Wrapped3
+        : boost::equivalent<Wrapped3<T> >
+        , boost::partially_ordered<Wrapped3<T> >
+        , boost::equality_comparable<Wrapped3<T> >
+    {
+    public:
+        explicit Wrapped3( T v = T() ) : _value(v) {}
+        T value() const { return _value; }
+
+        bool operator<(const Wrapped3& x) const { return _value < x._value; }
+        
+    private:
+        T _value;
+    };
+    template <class T>
+    T true_value(Wrapped3<T> x) { return x.value(); }    
+
+    template <class T, class U>
+    class Wrapped4
+        : boost::equality_comparable1<Wrapped4<T, U>
+        , boost::equivalent1<Wrapped4<T, U>
+        , boost::partially_ordered1<Wrapped4<T, U> > > >
+        , boost::partially_ordered2<Wrapped4<T, U>, U
+        , boost::equivalent2<Wrapped4<T, U>, U
+        , boost::equality_comparable2<Wrapped4<T, U>, U> > >
+    {
+    public:
+        explicit Wrapped4( T v = T() ) : _value(v) {}
+        T value() const { return _value; }
+
+        bool operator<(const Wrapped4& x) const { return _value < x._value; }
+         
+        bool operator<(U u) const { return _value < u; }
+        bool operator>(U u) const { return _value > u; }
+
+    private:
+        T _value;
+    };
+    template <class T, class U>
+    T true_value(Wrapped4<T,U> x) { return x.value(); }
+    
    //  MyInt uses only the single template-argument form of all_operators<>
    typedef Wrapped1<int> MyInt;

    typedef Wrapped2<long, long> MyLong;

+    typedef Wrapped3<signed char> MyChar;
+
+    typedef Wrapped4<short, short> MyShort;
+
    template <class X1, class Y1, class X2, class Y2>
    void sanity_check(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        assert(true_value(y1) == true_value(y2));
-        assert(true_value(x1) == true_value(x2));
+        BOOST_TEST( true_value(y1) == true_value(y2) );
+        BOOST_TEST( true_value(x1) == true_value(x2) );
    }

    template <class X1, class Y1, class X2, class Y2>
    void test_less_than_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        assert((x1 < y1) == (x2 < y2));
-        assert((x1 <= y1) == (x2 <= y2));
-        assert((x1 >= y1) == (x2 >= y2));
-        assert((x1 > y1) == (x2 > y2));
+        BOOST_TEST( (x1 < y1) == (x2 < y2) );
+        BOOST_TEST( (x1 <= y1) == (x2 <= y2) );
+        BOOST_TEST( (x1 >= y1) == (x2 >= y2) );
+        BOOST_TEST( (x1 > y1) == (x2 > y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_less_than_comparable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        test_less_than_comparable_aux(x1, y1, x2, y2);
-        test_less_than_comparable_aux(y1, x1, y2, x2);
+        sanity_check( x1, y1, x2, y2 );
+        test_less_than_comparable_aux( x1, y1, x2, y2 );
+        test_less_than_comparable_aux( y1, x1, y2, x2 );
    }

    template <class X1, class Y1, class X2, class Y2>
    void test_equality_comparable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        assert((x1 == y1) == (x2 == y2));
-        assert((x1 != y1) == (x2 != y2));
+        BOOST_TEST( (x1 == y1) == (x2 == y2) );
+        BOOST_TEST( (x1 != y1) == (x2 != y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_equality_comparable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        test_equality_comparable_aux(x1, y1, x2, y2);
-        test_equality_comparable_aux(y1, x1, y2, x2);
+        sanity_check( x1, y1, x2, y2 );
+        test_equality_comparable_aux( x1, y1, x2, y2 );
+        test_equality_comparable_aux( y1, x1, y2, x2 );
    }

    template <class X1, class Y1, class X2, class Y2>
    void test_multipliable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        assert((x1 * y1).value() == (x2 * y2));
+        BOOST_TEST( (x1 * y1).value() == (x2 * y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_multipliable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        test_multipliable_aux(x1, y1, x2, y2);
-        test_multipliable_aux(y1, x1, y2, x2);
+        sanity_check( x1, y1, x2, y2 );
+        test_multipliable_aux( x1, y1, x2, y2 );
+        test_multipliable_aux( y1, x1, y2, x2 );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_addable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        assert((x1 + y1).value() == (x2 + y2));
+        BOOST_TEST( (x1 + y1).value() == (x2 + y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_addable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        test_addable_aux(x1, y1, x2, y2);
-        test_addable_aux(y1, x1, y2, x2);
+        sanity_check( x1, y1, x2, y2 );
+        test_addable_aux( x1, y1, x2, y2 );
+        test_addable_aux( y1, x1, y2, x2 );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_subtractable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        assert((x1 - y1).value() == x2 - y2);
+        sanity_check( x1, y1, x2, y2 );
+        BOOST_TEST( (x1 - y1).value() == (x2 - y2) );
    }

    template <class X1, class Y1, class X2, class Y2>
    void test_dividable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        if (y2 != 0)
-            assert((x1 / y1).value() == x2 / y2);
+        sanity_check( x1, y1, x2, y2 );
+        if ( y2 != 0 )
+            BOOST_TEST( (x1 / y1).value() == (x2 / y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_modable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        if (y2 != 0)
-            assert((x1 / y1).value() == x2 / y2);
+        sanity_check( x1, y1, x2, y2 );
+        if ( y2 != 0 )
+            BOOST_TEST( (x1 % y1).value() == (x2 % y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_xorable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        assert((x1 ^ y1).value() == (x2 ^ y2));
+        BOOST_TEST( (x1 ^ y1).value() == (x2 ^ y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_xorable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        test_xorable_aux(x1, y1, x2, y2);
-        test_xorable_aux(y1, x1, y2, x2);
+        sanity_check( x1, y1, x2, y2 );
+        test_xorable_aux( x1, y1, x2, y2 );
+        test_xorable_aux( y1, x1, y2, x2 );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_andable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        assert((x1 & y1).value() == (x2 & y2));
+        BOOST_TEST( (x1 & y1).value() == (x2 & y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_andable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        test_andable_aux(x1, y1, x2, y2);
-        test_andable_aux(y1, x1, y2, x2);
+        sanity_check( x1, y1, x2, y2 );
+        test_andable_aux( x1, y1, x2, y2 );
+        test_andable_aux( y1, x1, y2, x2 );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_orable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        assert((x1 | y1).value() == (x2 | y2));
+        BOOST_TEST( (x1 | y1).value() == (x2 | y2) );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_orable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        sanity_check(x1, y1, x2, y2);
-        test_orable_aux(x1, y1, x2, y2);
-        test_orable_aux(y1, x1, y2, x2);
+        sanity_check( x1, y1, x2, y2 );
+        test_orable_aux( x1, y1, x2, y2 );
+        test_orable_aux( y1, x1, y2, x2 );
+    }
+    
+    template <class X1, class Y1, class X2, class Y2>
+    void test_left_shiftable(X1 x1, Y1 y1, X2 x2, Y2 y2)
+    {
+        sanity_check( x1, y1, x2, y2 );
+        BOOST_TEST( (x1 << y1).value() == (x2 << y2) );
+    }
+    
+    template <class X1, class Y1, class X2, class Y2>
+    void test_right_shiftable(X1 x1, Y1 y1, X2 x2, Y2 y2)
+    {
+        sanity_check( x1, y1, x2, y2 );
+        BOOST_TEST( (x1 >> y1).value() == (x2 >> y2) );
    }
    
    template <class X1, class X2>
    void test_incrementable(X1 x1, X2 x2)
    {
-        sanity_check(x1, x1, x2, x2);
-        assert(x1++.value() == x2++);
-        assert(x1.value() == x2);
+        sanity_check( x1, x1, x2, x2 );
+        BOOST_TEST( (x1++).value() == x2++ );
+        BOOST_TEST( x1.value() == x2 );
    }
    
    template <class X1, class X2>
    void test_decrementable(X1 x1, X2 x2)
    {
-        sanity_check(x1, x1, x2, x2);
-        assert(x1--.value() == x2--);
-        assert(x1.value() == x2);
+        sanity_check( x1, x1, x2, x2 );
+        BOOST_TEST( (x1--).value() == x2-- );
+        BOOST_TEST( x1.value() == x2 );
    }
    
    template <class X1, class Y1, class X2, class Y2>
    void test_all(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
-        test_less_than_comparable(x1, y1, x2, y2);
-        test_equality_comparable(x1, y1, x2, y2);
-        test_multipliable(x1, y1, x2, y2);
-        test_addable(x1, y1, x2, y2);
-        test_subtractable(x1, y1, x2, y2);
-        test_dividable(x1, y1, x2, y2);
-        test_modable(x1, y1, x2, y2);
-        test_xorable(x1, y1, x2, y2);
-        test_andable(x1, y1, x2, y2);
-        test_orable(x1, y1, x2, y2);
-        test_incrementable(x1, x2);
-        test_decrementable(x1, x2);
+        test_less_than_comparable( x1, y1, x2, y2 );
+        test_equality_comparable( x1, y1, x2, y2 );
+        test_multipliable( x1, y1, x2, y2 );
+        test_addable( x1, y1, x2, y2 );
+        test_subtractable( x1, y1, x2, y2 );
+        test_dividable( x1, y1, x2, y2 );
+        test_modable( x1, y1, x2, y2 );
+        test_xorable( x1, y1, x2, y2 );
+        test_andable( x1, y1, x2, y2 );
+        test_orable( x1, y1, x2, y2 );
+        test_left_shiftable( x1, y1, x2, y2 );
+        test_right_shiftable( x1, y1, x2, y2 );
+        test_incrementable( x1, x2 );
+        test_decrementable( x1, x2 );
    }
    
    template <class Big, class Small>
    struct tester
    {
-        void operator()(boost::min_rand& randomizer) const
+        void operator()(boost::minstd_rand& randomizer) const
        {
-            Big b1 = Big(randomizer());
-            Big b2 = Big(randomizer());
-            Small s = Small(randomizer());
+            Big    b1 = Big( randomizer() );
+            Big    b2 = Big( randomizer() );
+            Small  s = Small( randomizer() );
            
-            test_all(Wrapped1<Big>(b1), Wrapped1<Big>(b2), b1, b2);
-            test_all(Wrapped2<Big, Small>(b1), s, b1, s);
+            test_all( Wrapped1<Big>(b1), Wrapped1<Big>(b2), b1, b2 );
+            test_all( Wrapped2<Big, Small>(b1), s, b1, s );
        }
    };

    // added as a regression test. We had a bug which this uncovered.
    struct Point
-        : boost::addable<Point,
-        boost::subtractable<Point> >
+        : boost::addable<Point
+        , boost::subtractable<Point> >
    {
        Point( int h, int v ) : h(h), v(v) {}
        Point() :h(0), v(0) {}
-        const Point& operator+=( const Point& rhs ) { h += rhs.h; v += rhs.v; return *this; }
-        const Point& operator-=( const Point& rhs ) { h -= rhs.h; v -= rhs.v; return *this; }
+        const Point& operator+=( const Point& rhs )
+            { h += rhs.h; v += rhs.v; return *this; }
+        const Point& operator-=( const Point& rhs )
+            { h -= rhs.h; v -= rhs.v; return *this; }

        int h;
        int v;
    };
+
 } // unnamed namespace


@ -340,20 +429,25 @@ template Wrapped2<unsigned long, unsigned char>;
 template Wrapped2<unsigned long, unsigned long>;
 #endif

-#ifdef NDEBUG
-#error This program is pointless when NDEBUG disables assert()!
-#endif
+#define PRIVATE_EXPR_TEST(e, t)  BOOST_TEST( ((e), (t)) )

-int main()
+
+int
+test_main( int , char * [] )
 {
+    using std::cout;
+    using std::endl;
+
    // Regression test.
    Point x;
    x = x + Point(3, 4);
    x = x - Point(3, 4);
    
+    cout << "Created point, and operated on it." << endl;
+    
    for (int n = 0; n < 10000; ++n)
    {
-        boost::min_rand r;
+        boost::minstd_rand r;
        tester<long, int>()(r);
        tester<long, signed char>()(r);
        tester<long, long>()(r);
@ -367,115 +461,197 @@ int main()
        tester<unsigned int, unsigned char>()(r);
    }
    
+    cout << "Did random tester loop." << endl;
+
    MyInt i1(1);
    MyInt i2(2);
    MyInt i;

-    assert( i1.value() == 1 );
-    assert( i2.value() == 2 );
-    assert( i.value() == 0 );
+    BOOST_TEST( i1.value() == 1 );
+    BOOST_TEST( i2.value() == 2 );
+    BOOST_TEST( i.value() == 0 );

-    i = i2;
-    assert( i.value() == 2 );
-    assert( i2 == i );
-    assert( i1 != i2 );
-    assert( i1 <  i2 );
-    assert( i1 <= i2 );
-    assert( i <= i2 );
-    assert( i2 >  i1 );
-    assert( i2 >= i1 );
-    assert( i2 >= i );
+    cout << "Created MyInt objects.\n";

-    i = i1 + i2; assert( i.value() == 3 );
-    i = i + i2; assert( i.value() == 5 );
-    i = i - i1; assert( i.value() == 4 );
-    i = i * i2; assert( i.value() == 8 );
-    i = i / i2; assert( i.value() == 4 );
-    i = i % (i - i1); assert( i.value() == 1 );
-    i = i2 + i2; assert( i.value() == 4 );
-    i = i1 | i2 | i; assert( i.value() == 7 );
-    i = i & i2; assert( i.value() == 2 );
-    i = i + i1; assert( i.value() == 3 );
-    i = i ^ i1; assert( i.value() == 2 );
-    i = (i+i1)*(i2|i1); assert( i.value() == 9 );
+    PRIVATE_EXPR_TEST( (i = i2), (i.value() == 2) );
+
+    BOOST_TEST( i2 == i );
+    BOOST_TEST( i1 != i2 );
+    BOOST_TEST( i1 <  i2 );
+    BOOST_TEST( i1 <= i2 );
+    BOOST_TEST( i <= i2 );
+    BOOST_TEST( i2 >  i1 );
+    BOOST_TEST( i2 >= i1 );
+    BOOST_TEST( i2 >= i );
+
+    PRIVATE_EXPR_TEST( (i = i1 + i2), (i.value() == 3) );
+    PRIVATE_EXPR_TEST( (i = i + i2), (i.value() == 5) );
+    PRIVATE_EXPR_TEST( (i = i - i1), (i.value() == 4) );
+    PRIVATE_EXPR_TEST( (i = i * i2), (i.value() == 8) );
+    PRIVATE_EXPR_TEST( (i = i / i2), (i.value() == 4) );
+    PRIVATE_EXPR_TEST( (i = i % ( i - i1 )), (i.value() == 1) );
+    PRIVATE_EXPR_TEST( (i = i2 + i2), (i.value() == 4) );
+    PRIVATE_EXPR_TEST( (i = i1 | i2 | i), (i.value() == 7) );
+    PRIVATE_EXPR_TEST( (i = i & i2), (i.value() == 2) );
+    PRIVATE_EXPR_TEST( (i = i + i1), (i.value() == 3) );
+    PRIVATE_EXPR_TEST( (i = i ^ i1), (i.value() == 2) );
+    PRIVATE_EXPR_TEST( (i = ( i + i1 ) * ( i2 | i1 )), (i.value() == 9) );
+
+    PRIVATE_EXPR_TEST( (i = i1 << i2), (i.value() == 4) );
+    PRIVATE_EXPR_TEST( (i = i2 >> i1), (i.value() == 1) );
    
+    cout << "Performed tests on MyInt objects.\n";
+
    MyLong j1(1);
    MyLong j2(2);
    MyLong j;

-    assert( j1.value() == 1 );
-    assert( j2.value() == 2 );
-    assert( j.value() == 0 );
+    BOOST_TEST( j1.value() == 1 );
+    BOOST_TEST( j2.value() == 2 );
+    BOOST_TEST( j.value() == 0 );

-    j = j2;
-    assert( j.value() == 2 );
-    
-    assert( j2 == j );
-    assert( 2 == j );
-    assert( j2 == 2 );    
-    assert( j == j2 );
-    assert( j1 != j2 );
-    assert( j1 != 2 );
-    assert( 1 != j2 );
-    assert( j1 <  j2 );
-    assert( 1 <  j2 );
-    assert( j1 <  2 );
-    assert( j1 <= j2 );
-    assert( 1 <= j2 );
-    assert( j1 <= j );
-    assert( j <= j2 );
-    assert( 2 <= j2 );
-    assert( j <= 2 );
-    assert( j2 >  j1 );
-    assert( 2 >  j1 );
-    assert( j2 >  1 );
-    assert( j2 >= j1 );
-    assert( 2 >= j1 );
-    assert( j2 >= 1 );
-    assert( j2 >= j );
-    assert( 2 >= j );
-    assert( j2 >= 2 );
+    cout << "Created MyLong objects.\n";

-    assert( (j1 + 2) == 3 );
-    assert( (1 + j2) == 3 );
-    j = j1 + j2; assert( j.value() == 3 );
+    PRIVATE_EXPR_TEST( (j = j2), (j.value() == 2) );
    
-    assert( (j + 2) == 5 );
-    assert( (3 + j2) == 5 );
-    j = j + j2; assert( j.value() == 5 );
+    BOOST_TEST( j2 == j );
+    BOOST_TEST( 2 == j );
+    BOOST_TEST( j2 == 2 );    
+    BOOST_TEST( j == j2 );
+    BOOST_TEST( j1 != j2 );
+    BOOST_TEST( j1 != 2 );
+    BOOST_TEST( 1 != j2 );
+    BOOST_TEST( j1 <  j2 );
+    BOOST_TEST( 1 <  j2 );
+    BOOST_TEST( j1 <  2 );
+    BOOST_TEST( j1 <= j2 );
+    BOOST_TEST( 1 <= j2 );
+    BOOST_TEST( j1 <= j );
+    BOOST_TEST( j <= j2 );
+    BOOST_TEST( 2 <= j2 );
+    BOOST_TEST( j <= 2 );
+    BOOST_TEST( j2 >  j1 );
+    BOOST_TEST( 2 >  j1 );
+    BOOST_TEST( j2 >  1 );
+    BOOST_TEST( j2 >= j1 );
+    BOOST_TEST( 2 >= j1 );
+    BOOST_TEST( j2 >= 1 );
+    BOOST_TEST( j2 >= j );
+    BOOST_TEST( 2 >= j );
+    BOOST_TEST( j2 >= 2 );
+
+    BOOST_TEST( (j1 + 2) == 3 );
+    BOOST_TEST( (1 + j2) == 3 );
+    PRIVATE_EXPR_TEST( (j = j1 + j2), (j.value() == 3) );
    
-    assert( (j - 1) == 4 );
-    j = j - j1; assert( j.value() == 4 );
+    BOOST_TEST( (j + 2) == 5 );
+    BOOST_TEST( (3 + j2) == 5 );
+    PRIVATE_EXPR_TEST( (j = j + j2), (j.value() == 5) );
    
-    assert( (j * 2) == 8 );
-    assert( (4 * j2) == 8 );
-    j = j * j2; assert( j.value() == 8 );
+    BOOST_TEST( (j - 1) == 4 );
+    PRIVATE_EXPR_TEST( (j = j - j1), (j.value() == 4) );
    
-    assert( (j / 2) == 4 );
-    j = j / j2; assert( j.value() == 4 );
+    BOOST_TEST( (j * 2) == 8 );
+    BOOST_TEST( (4 * j2) == 8 );
+    PRIVATE_EXPR_TEST( (j = j * j2), (j.value() == 8) );
    
-    assert( (j % 3) == 1 );
-    j = j % (j - j1); assert( j.value() == 1 );
+    BOOST_TEST( (j / 2) == 4 );
+    PRIVATE_EXPR_TEST( (j = j / j2), (j.value() == 4) );
    
-    j = j2 + j2; assert( j.value() == 4 );
+    BOOST_TEST( (j % 3) == 1 );
+    PRIVATE_EXPR_TEST( (j = j % ( j - j1 )), (j.value() == 1) );
    
-    assert( (1 | j2 | j) == 7 );
-    assert( (j1 | 2 | j) == 7 );
-    assert( (j1 | j2 | 4) == 7 );
-    j = j1 | j2 | j; assert( j.value() == 7 );
+    PRIVATE_EXPR_TEST( (j = j2 + j2), (j.value() == 4) );
    
-    assert( (7 & j2) == 2 );
-    assert( (j & 2) == 2 );
-    j = j & j2; assert( j.value() == 2 );
+    BOOST_TEST( (1 | j2 | j) == 7 );
+    BOOST_TEST( (j1 | 2 | j) == 7 );
+    BOOST_TEST( (j1 | j2 | 4) == 7 );
+    PRIVATE_EXPR_TEST( (j = j1 | j2 | j), (j.value() == 7) );
    
-    j = j | j1; assert( j.value() == 3 );
+    BOOST_TEST( (7 & j2) == 2 );
+    BOOST_TEST( (j & 2) == 2 );
+    PRIVATE_EXPR_TEST( (j = j & j2), (j.value() == 2) );
    
-    assert( (3 ^ j1) == 2 );
-    assert( (j ^ 1) == 2 );
-    j = j ^ j1; assert( j.value() == 2 );
+    PRIVATE_EXPR_TEST( (j = j | j1), (j.value() == 3) );
    
-    j = (j+j1)*(j2|j1); assert( j.value() == 9 );
+    BOOST_TEST( (3 ^ j1) == 2 );
+    BOOST_TEST( (j ^ 1) == 2 );
+    PRIVATE_EXPR_TEST( (j = j ^ j1), (j.value() == 2) );
    
-    std::cout << "0 errors detected\n";
-    return 0;
+    PRIVATE_EXPR_TEST( (j = ( j + j1 ) * ( j2 | j1 )), (j.value() == 9) );
+
+    BOOST_TEST( (j1 << 2) == 4 );
+    BOOST_TEST( (j2 << 1) == 4 );
+    PRIVATE_EXPR_TEST( (j = j1 << j2), (j.value() == 4) );
+
+    BOOST_TEST( (j >> 2) == 1 );
+    BOOST_TEST( (j2 >> 1) == 1 );
+    PRIVATE_EXPR_TEST( (j = j2 >> j1), (j.value() == 1) );
+    
+    cout << "Performed tests on MyLong objects.\n";
+
+    MyChar k1(1);
+    MyChar k2(2);
+    MyChar k;
+
+    BOOST_TEST( k1.value() == 1 );
+    BOOST_TEST( k2.value() == 2 );
+    BOOST_TEST( k.value() == 0 );
+
+    cout << "Created MyChar objects.\n";
+
+    PRIVATE_EXPR_TEST( (k = k2), (k.value() == 2) );
+
+    BOOST_TEST( k2 == k );
+    BOOST_TEST( k1 != k2 );
+    BOOST_TEST( k1 <  k2 );
+    BOOST_TEST( k1 <= k2 );
+    BOOST_TEST( k <= k2 );
+    BOOST_TEST( k2 >  k1 );
+    BOOST_TEST( k2 >= k1 );
+    BOOST_TEST( k2 >= k );
+    
+    cout << "Performed tests on MyChar objects.\n";
+
+    MyShort l1(1);
+    MyShort l2(2);
+    MyShort l;
+
+    BOOST_TEST( l1.value() == 1 );
+    BOOST_TEST( l2.value() == 2 );
+    BOOST_TEST( l.value() == 0 );
+
+    cout << "Created MyShort objects.\n";
+
+    PRIVATE_EXPR_TEST( (l = l2), (l.value() == 2) );
+    
+    BOOST_TEST( l2 == l );
+    BOOST_TEST( 2 == l );
+    BOOST_TEST( l2 == 2 );    
+    BOOST_TEST( l == l2 );
+    BOOST_TEST( l1 != l2 );
+    BOOST_TEST( l1 != 2 );
+    BOOST_TEST( 1 != l2 );
+    BOOST_TEST( l1 <  l2 );
+    BOOST_TEST( 1 <  l2 );
+    BOOST_TEST( l1 <  2 );
+    BOOST_TEST( l1 <= l2 );
+    BOOST_TEST( 1 <= l2 );
+    BOOST_TEST( l1 <= l );
+    BOOST_TEST( l <= l2 );
+    BOOST_TEST( 2 <= l2 );
+    BOOST_TEST( l <= 2 );
+    BOOST_TEST( l2 >  l1 );
+    BOOST_TEST( 2 >  l1 );
+    BOOST_TEST( l2 >  1 );
+    BOOST_TEST( l2 >= l1 );
+    BOOST_TEST( 2 >= l1 );
+    BOOST_TEST( l2 >= 1 );
+    BOOST_TEST( l2 >= l );
+    BOOST_TEST( 2 >= l );
+    BOOST_TEST( l2 >= 2 );
+    
+    cout << "Performed tests on MyShort objects.\n";
+    
+    return boost::exit_success;
 }
--- a/projection_iterator.htm
+++ b/projection_iterator.htm
@ -371,7 +371,7 @@ Betty
 </pre>

 <hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->16 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14385" --></p>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" --></p>
 <p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
 modify, sell and distribute this document is granted provided this copyright
 notice appears in all copies. This document is provided &quot;as is&quot;
--- a/reverse_iterator.htm
+++ b/reverse_iterator.htm
@ -312,7 +312,7 @@ simply use <tt>reverse_iterator_generator</tt> twice!<br><br>

    
    <p>Revised 
-    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->26 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14386" -->
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->


    <p>&copy; Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell
--- a/tie.html
+++ b/tie.html
@ -23,7 +23,13 @@
 <TT>tie</TT>
 </H1>

-<P>
+<h3>
+[This version of tie has been removed from the utility.hpp
+header.&nbsp; There is a new, more general version of <a
+href="../tuple/doc/tuple_users_guide.html#tiers">tie</a> in the Boost
+Tuples Library. The more general version handles an (almost) arbitrary
+number of arguments, instead of just two. The version in utility.hpp
+had to be removed to avoid name clashes.]</h3>
 <PRE>
 template &lt;class A, class B&gt;
 tied&lt;A,B&gt; tie(A&amp; a, B&amp; b);
@ -64,7 +70,7 @@ pair of iterators is assigned to the iterator variables <TT>i</TT> and

 <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>.
+href="http://www.sgi.com/tech/stl/set.html"><TT>std::set</TT></a>.

 <P>
 <PRE>
@ -124,7 +130,7 @@ The output is:
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
+<a HREF="../../people/jeremy_siek.htm">Jeremy Siek</a>,
 Univ.of Notre Dame (<A
 HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<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/tie_example.cpp
+++ b/tie_example.cpp
@ -14,19 +14,21 @@
 //
 // 3 successfully inserted.
 // 9 was already in the set.
-// There were 2 occurances of 4.
+// There were 2 occurrences of 4.

 #include <set>
 #include <algorithm>
 #include <iostream>
-#include <boost/utility.hpp>
+// Note: tie() use to live in boost/utility.hpp, but
+// not it is part of the more general Boost Tuple Library.
+#include <boost/tuple/tuple.hpp>

 int
 main(int, char*[])
 {
  {
    typedef std::set<int> SetT;
-    SetT::iterator i, end;
+    SetT::iterator i;
    bool inserted;
    
    int vals[5] = { 5, 2, 4, 9, 1 };
@ -53,7 +55,7 @@ main(int, char*[])

    boost::tie(i,end) = std::equal_range(vals, vals + 6, 4);
    std::cout << "There were " << std::distance(i,end)
-	      << " occurances of " << *i << "." << std::endl;
+	      << " occurrences of " << *i << "." << std::endl;
    // Footnote: of course one would normally just use std::count()
    // to get this information, but that would spoil the example :)
  }
--- a/transform_iterator.htm
+++ b/transform_iterator.htm
@ -71,8 +71,11 @@ public:

 <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.
+<tt>transform_iterator_generator</tt> class to iterate through a range
+of numbers, multiplying each of them by 2 when they are dereferenced.
+The <tt>boost::binder1st</tt> class is used instead of the standard
+one because tranform iterator requires the function object to be
+Default Constructible.

 <p>
 <PRE>
@ -80,16 +83,18 @@ numbers, multiplying each of them by 2 when they are dereferenced.
 #include &lt;iostream&gt;
 #include &lt;boost/iterator_adaptors.hpp&gt;

+// definition of class boost::binder1st and function boost::bind1st() ...
+
 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::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));
+  doubling_iterator i(x, boost::bind1st(std::multiplies&lt;int&gt;(), 2)),
+    i_end(x + sizeof(x)/sizeof(int), boost::bind1st(std::multiplies&lt;int&gt;(), 2));

  std::cout &lt;&lt; "multiplying the array by 2:" &lt;&lt; std::endl;
  while (i != i_end)
@ -111,14 +116,17 @@ The output from this part is:
 </TR>

 <TR>
-<TD><a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html"><tt>AdaptableUnaryFunction</tt></a></TD>
+<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>
+its argument. Also, the function object must be <a
+href="http://www.sgi.com/tech/stl/DefaultConstructible.html"> Default
+Constructible</a> (which many of the standard function objects are not).</TD>
 </TR>

 <TR>
@ -133,7 +141,7 @@ its argument.</TD>

 The transform iterator adaptor (the type
 <tt>transform_iterator_generator<...>::type</tt>) is a model of <a
-href="www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a><a href="#1">[1]</a>.
+href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a><a href="#1">[1]</a>.


 <h3>Members</h3>
@ -173,8 +181,8 @@ 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::copy(boost::make_transform_iterator(x, boost::bind1st(std::plus<int>(), 4)),
+	    boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
 	    std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;

@ -203,7 +211,7 @@ iterator always returns by-value.


 <hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->16 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14385" --></p>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" --></p>
 <p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
 modify, sell and distribute this document is granted provided this copyright
 notice appears in all copies. This document is provided &quot;as is&quot;
--- a/transform_iterator_example.cpp
+++ b/transform_iterator_example.cpp
@ -9,6 +9,38 @@
 #include <iostream>
 #include <boost/iterator_adaptors.hpp>

+// What a bummer. We can't use std::binder1st with transform iterator
+// because it does not have a default constructor. Here's a version
+// that does.
+
+namespace boost {
+
+  template <class Operation> 
+  class binder1st
+    : public std::unary_function<typename Operation::second_argument_type,
+			         typename Operation::result_type> {
+  protected:
+    Operation op;
+    typename Operation::first_argument_type value;
+  public:
+    binder1st() { } // this had to be added!
+    binder1st(const Operation& x,
+	      const typename Operation::first_argument_type& y)
+	: op(x), value(y) {}
+    typename Operation::result_type
+    operator()(const typename Operation::second_argument_type& x) const {
+      return op(value, x); 
+    }
+  };
+
+  template <class Operation, class T>
+  inline binder1st<Operation> bind1st(const Operation& op, const T& x) {
+    typedef typename Operation::first_argument_type arg1_type;
+    return binder1st<Operation>(op, arg1_type(x));
+  }
+
+} // namespace boost
+
 int
 main(int, char*[])
 {
@ -20,11 +52,11 @@ main(int, char*[])
  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::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));
+  doubling_iterator i(x, boost::bind1st(std::multiplies<int>(), 2)),
+    i_end(x + N, boost::bind1st(std::multiplies<int>(), 2));

  std::cout << "multiplying the array by 2:" << std::endl;
  while (i != i_end)
@ -33,8 +65,8 @@ main(int, char*[])

  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::copy(boost::make_transform_iterator(x, boost::bind1st(std::plus<int>(), 4)),
+	    boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
 	    std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;
  
--- 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/utility.htm
+++ b/utility.htm
@ -16,10 +16,52 @@
 <h2>Contents</h2>

 <ul>
+  <li>Class templates supporting the <a href="base_from_member.html">base-from-member
+    idiom</a></li>
+  <li>Function templates <a href="#checked_delete">checked_delete() and
+    checked_array_delete()</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> Function templates <a name="checked_delete">checked_delete</a>() and
+checked_array_delete()</h2>
+
+<p>Deletion of a pointer to an incomplete type is an unsafe programming practice
+because there is no way for the compiler to verify that the destructor is indeed
+trivial.&nbsp; The checked_delete() and checked_array_delete() function
+templates simply <b>delete</b> or <b>delete[]</b> their argument, but also
+require that their argument be a complete type.&nbsp; They issue an appropriate
+compiler error diagnostic if that requirement is not met.&nbsp; A typical
+implementation is shown; other implementations may vary:</p>
+
+<pre>    template&lt; typename T &gt;
+    inline void checked_delete(T const volatile * x)
+    {
+        BOOST_STATIC_ASSERT( sizeof(T) ); // assert type complete at point
+                                          // of instantiation
+        delete x;
+    }
+
+    template&lt; typename T &gt;
+    inline void checked_array_delete(T const volatile * x)
+    {
+        BOOST_STATIC_ASSERT( sizeof(T) ); // assert type complete at point
+                                          // of instantiation
+        delete [] x;
+    }</pre>
+
+<p>Contributed by Beman Dawes, based on a suggestion from Dave Abrahams,
+generalizing an idea from Vladimir Prus, with comments from Rainer Deyke, John
+Maddock, and others.</p>
+
+<h3>Background</h3>
+
+<p>The C++ Standard specifies that delete on a pointer to an incomplete types is
+undefined behavior if the type has a non-trivial destructor in&nbsp; [expr.delete]
+5.3.5 paragraph.&nbsp; No diagnostic is required.&nbsp; Some but not all
+compilers issue warnings if the type is incomplete at point of deletion.</p>
+
 <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
@ -91,9 +133,13 @@ emphasize that it is to be used only as a base class.&nbsp; Dave Abrahams notes
 concern about the effect on compiler optimization of adding (even trivial inline)
 destructor declarations. He says &quot;Probably this concern is misplaced, because
 noncopyable will be used mostly for classes which own resources and thus have non-trivial destruction semantics.&quot;</p>
+<h2>Class templates for the Base-from-Member Idiom</h2>
+<p>See <a href="base_from_member.html">separate documentation</a>.</p>
+<h2>Function template tie()</h2>
+<p>See <a href="tie.html">separate documentation</a>.</p>
 <hr>
 <p>Revised&nbsp; <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
-->16 February, 2001<!--webbot bot="Timestamp" endspan i-checksum="40407"
+-->10 September, 2001<!--webbot bot="Timestamp" endspan i-checksum="39328"
 -->
 </p>
 <p><EFBFBD> Copyright boost.org 1999. Permission to copy, use, modify, sell and
Author	SHA1	Message	Date
nobody	7963ec54f1	This commit was manufactured by cvs2svn to create tag 'Version_1_25_1'. [SVN r11623]	2001-11-07 10:35:13 +00:00
Dave Abrahams	75eaa14a18	Removed defunct boost::tied (thanks, Daryle Walker) [SVN r11622]	2001-11-07 10:35:12 +00:00
Jeremy Siek	082d6e3b32	* empty log message * [SVN r11614]	2001-11-06 16:09:14 +00:00
Jeremy Siek	35b3770b6f	* empty log message * [SVN r11613]	2001-11-06 16:05:25 +00:00
Jeremy Siek	5b9d20c7e2	* empty log message * [SVN r11611]	2001-11-06 15:52:56 +00:00
Jeremy Siek	5bbed2372e	* empty log message * [SVN r11602]	2001-11-05 21:03:59 +00:00
Jens Maurer	a9d407d239	update SunCC to 6.u2 (C++ 5.3) [SVN r11601]	2001-11-05 21:00:53 +00:00
Jeremy Siek	3ca4a33a65	updated for named parameters [SVN r11566]	2001-11-04 16:21:51 +00:00
Jeremy Siek	95197f427c	remoeved #if 0 [SVN r11565]	2001-11-04 16:18:10 +00:00
Jeremy Siek	84cdfb032c	commit these changes [SVN r11563]	2001-11-04 04:37:14 +00:00
Dave Abrahams	ec2ceb9c96	no message [SVN r11508]	2001-11-01 17:22:39 +00:00
John Maddock	6286c893fd	Minor regression fixes for Borland and Sunpro tests. [SVN r11470]	2001-10-30 11:41:35 +00:00
Jeremy Siek	354aef0e8c	changed named parameters doc to match new stuff [SVN r11417]	2001-10-22 17:04:23 +00:00
John Maddock	139e33c36d	Updated preprocessor logic to use BOOST_HAS_LONG_LONG [SVN r11399]	2001-10-18 11:33:52 +00:00
Dave Abrahams	e01de59cdd	Made these actually compile [SVN r11378]	2001-10-12 22:22:42 +00:00
Darin Adler	686f822dea	Fix spelling error: "occurances" -> "occurrences". [SVN r11376]	2001-10-11 17:26:04 +00:00
John Maddock	9961d5c9af	Last fix had broken preprocessor logic, now fixed. [SVN r11373]	2001-10-11 12:04:00 +00:00
John Maddock	628be0d125	Fixes for Sunpro C++ 5.3 (code now works!) [SVN r11368]	2001-10-09 11:24:56 +00:00
John Maddock	633e45f61a	Fixed test to work with sunpro 5.3 (omits array specialisation tests) [SVN r11359]	2001-10-08 11:35:05 +00:00
John Maddock	2f357c3805	Partial fixes for sunpro 5.3 - doesn't actually work yet though [SVN r11355]	2001-10-08 11:31:29 +00:00
John Maddock	cda0894d0d	Fix for sunpro 5.3 (array specialisations don't work) [SVN r11354]	2001-10-08 11:30:53 +00:00
Beman Dawes	117720a8bc	1.25.0 Final runup [SVN r11315]	2001-10-01 15:54:23 +00:00
Beman Dawes	a6f6c3613a	Change comments to make it clear why forward declaration header is required. [SVN r11314]	2001-10-01 14:15:44 +00:00
Darin Adler	7914f5b931	Fixed unused variables that show up as warnings when doing regression tests. [SVN r11241]	2001-09-24 23:21:16 +00:00
John Maddock	a1add0a6f6	Intel C++ fixes: Added class copy constructor. [SVN r11200]	2001-09-22 11:52:56 +00:00
Beman Dawes	c032b337c4	Fix broken links and other HTML changes related to new config system [SVN r11142]	2001-09-18 21:24:51 +00:00
Jens Maurer	ec363261ae	remove "explicit" on two- and three-argument constructors to avoid error on HP aCC [SVN r11097]	2001-09-11 18:42:25 +00:00
Beman Dawes	97cde2183d	Initial base_from_member commit [SVN r11086]	2001-09-10 14:04:28 +00:00
Dave Abrahams	7f43c682db	Fixed the pair_generator documentation. Order of parameters was wrong; reordered the table to match the corrected order. [SVN r11035]	2001-09-05 16:29:29 +00:00
Jeremy Siek	0c9eee3c6b	changed note about the move to the tuples library [SVN r10972]	2001-08-30 19:45:19 +00:00
John Maddock	3b1afa3ba6	changed "empty-member" to "empty base-class" [SVN r10966]	2001-08-30 10:58:19 +00:00
Jeremy Siek	93e6a75125	changed #include for tie() to tuple.hpp [SVN r10951]	2001-08-28 19:09:33 +00:00
Jeremy Siek	52f8a7c0ca	changed #include for tie() [SVN r10950]	2001-08-28 19:07:51 +00:00
Jeremy Siek	55bfeb646f	removed tie() and class tied [SVN r10938]	2001-08-26 19:55:49 +00:00
Jeremy Siek	75c9dd3be1	added not about constness of operator* and operator[] [SVN r10931]	2001-08-24 15:28:20 +00:00
Dave Abrahams	6392e2788f	Removed incorrect statics, added const [SVN r10930]	2001-08-24 12:09:34 +00:00
Peter Dimov	6a97f3f9ba	Tabs converted to spaces. [SVN r10916]	2001-08-23 19:05:21 +00:00
Peter Dimov	6e5f52e279	initial commit [SVN r10914]	2001-08-23 18:42:16 +00:00
Darin Adler	7f92bed902	Fix some broken links. Fix order of constructor initializers. [SVN r10913]	2001-08-23 17:42:07 +00:00
Beman Dawes	d68a11cc42	Misc; mostly fix links to hard disk locations [SVN r10902]	2001-08-20 13:04:43 +00:00
Beman Dawes	328a81e194	Fix broken hyperlink [SVN r10896]	2001-08-19 15:08:33 +00:00
Beman Dawes	31d0908b74	Add workaround for BOOST_NO_STDC_NAMESPACE [SVN r10681]	2001-07-20 21:29:36 +00:00
Dave Abrahams	32c77599f4	Fixes for ICL [SVN r10613]	2001-07-14 12:51:59 +00:00
Beman Dawes	812ebf3562	Back out commit made in error [SVN r10596]	2001-07-12 16:15:30 +00:00
Beman Dawes	37f476013d	Change absolute URL's to relative [SVN r10594]	2001-07-12 15:31:15 +00:00
Dave Abrahams	9f3104166f	output_iterator_helper changes: removed default template parameters, added support for self-proxying, additional documentation and tests (Aleksey Gurtovoy) [SVN r10576]	2001-07-09 23:51:49 +00:00
Dave Abrahams	64cc0daf34	Integrate Aleksey's changes [SVN r10575]	2001-07-09 23:50:55 +00:00
Beman Dawes	d5d64df124	Fix broken link [SVN r10553]	2001-07-06 19:19:45 +00:00
Beman Dawes	0edcfcd5c1	Tuples library causes tie to be deprecated [SVN r10552]	2001-07-06 19:16:39 +00:00
John Maddock	50ba2d419a	Tweeked gcc workaround (gcc 3 still has same problem as gcc 2.9x), added tentative Metrowerks and Intel compiler workarounds. [SVN r10422]	2001-06-25 11:31:14 +00:00
John Maddock	ff3a77ca5a	Fixed problem with VC6 compilers - probably a temporary fix. [SVN r10361]	2001-06-20 11:43:57 +00:00
Jens Maurer	4eaed6c23d	remove superfluous, illegal "typename" (twice) [SVN r10314]	2001-06-12 18:50:37 +00:00
Jeremy Siek	4d0dd46471	meant to add as a branch [SVN r10280]	2001-06-06 19:16:34 +00:00
Jeremy Siek	9c2549bd00	files for the tmpw2001 paper about iterator adaptors [SVN r10278]	2001-06-06 19:08:51 +00:00
Dave Abrahams	b7c8e0c17f	changes from Daryle Walker [SVN r10264]	2001-06-04 11:57:37 +00:00
Jeremy Siek	dd3cfe1837	removed old arg ordering, use defaults instead [SVN r10258]	2001-06-03 20:00:24 +00:00
Beman Dawes	43f525298e	Remove compiler workarounds no longer needed due to BOOST_STATIC_ASSERT fix. For stylistic reasons, change sizeof() test to sizeof() != 0 [SVN r10236]	2001-05-28 14:22:30 +00:00
Beman Dawes	1bb1898ab9	Dave says qualifiers weren't really needed [SVN r10222]	2001-05-24 19:11:51 +00:00
Beman Dawes	9578f24be9	Workaround compiler problems while waiting to find out if BOOST_STATIC_ASSERT is broken [SVN r10218]	2001-05-24 16:02:42 +00:00
Jens Maurer	46fae3aed2	added check_delete workaround for Sun CC [SVN r10213]	2001-05-24 09:26:48 +00:00
Beman Dawes	e35f91a70a	Smart pointer and utility changes related to adding checked_delere and checked_array_delete [SVN r10189]	2001-05-22 18:58:21 +00:00
John Maddock	851052fcca	Updated docs - added VC6 bug warning [SVN r10062]	2001-05-08 11:17:44 +00:00
John Maddock	5ef81b2952	Updated/stricter test program [SVN r10061]	2001-05-08 11:17:05 +00:00
John Maddock	ef2851c053	Fixes for Sun C++ 5.1 [SVN r10060]	2001-05-08 11:16:35 +00:00
John Maddock	0b4387cff5	reorganised tests to show up VC6 bugs [SVN r10002]	2001-05-02 10:59:32 +00:00
John Maddock	a40cf11fbf	Rewritten compressed_pair regression script to test everything in a more methodical way [SVN r10000]	2001-05-01 11:17:02 +00:00
Beman Dawes	5c495cd223	Change all eGroups references to YahooGroups [SVN r9979]	2001-04-25 00:24:50 +00:00
Jeremy Siek	cf1296dff8	added stuff about Default Constructible needed for the function object [SVN r9683]	2001-03-29 16:26:42 +00:00
Jeremy Siek	d6d88db6e8	std::bind1st -> boost::bind1st [SVN r9682]	2001-03-29 16:19:34 +00:00
Jeremy Siek	85c2a35257	std::binder1st -> boost::binder1st [SVN r9681]	2001-03-29 16:18:41 +00:00
Jeremy Siek	836d8b1c64	added spaces in name [SVN r9673]	2001-03-29 04:08:38 +00:00
John Maddock	98d8c8ab71	fixed broken link [SVN r9645]	2001-03-27 10:54:12 +00:00
Jeremy Siek	db45013339	fixed sgi stl link [SVN r9631]	2001-03-22 16:06:15 +00:00
Jeremy Siek	a55c37e7f6	fixed sgi stl links [SVN r9630]	2001-03-22 16:05:48 +00:00
Jeremy Siek	46a270fcca	fixed link to sgi stl [SVN r9629]	2001-03-22 16:02:11 +00:00
Jeremy Siek	967856518e	updated link to sgi stl [SVN r9628]	2001-03-22 16:01:18 +00:00
Jeremy Siek	7f93e739fe	added documentation for initialize() policy function [SVN r9592]	2001-03-19 21:46:14 +00:00
Jeremy Siek	2cd1422514	added comment about abstract base classes as value_type [SVN r9584]	2001-03-19 17:31:27 +00:00
Beman Dawes	feb370b201	1.21.0 run up including fixing broken links [SVN r9523]	2001-03-09 14:36:41 +00:00
Dave Abrahams	d1b34e64d8	Fixes for validator.w3.org [SVN r9518]	2001-03-09 03:28:13 +00:00
Dave Abrahams	b9a1eead40	Mostly clarification. Fix: changed "category" to "iterator_category" in one place. [SVN r9517]	2001-03-09 03:10:32 +00:00
Jeremy Siek	1e4bfac98c	added named template parameter to table of contents [SVN r9510]	2001-03-08 21:36:09 +00:00
Jeremy Siek	3bb504fbf3	added revision history line [SVN r9506]	2001-03-08 20:50:14 +00:00
Jeremy Siek	5029791c90	split off indirect and transform tests into separate files [SVN r9505]	2001-03-08 20:49:05 +00:00
Beman Dawes	a1a68f0970	1.21.0 run up [SVN r9502]	2001-03-08 20:35:52 +00:00
Jeremy Siek	f8543d79eb	added more static asserts [SVN r9500]	2001-03-08 20:02:00 +00:00
Jeremy Siek	f353415136	added docs for iterator_traits_generator [SVN r9498]	2001-03-08 19:19:46 +00:00
Jeremy Siek	26240403b0	added a test to make sure that the type set by the generator is really the type used [SVN r9497]	2001-03-08 19:04:29 +00:00
Jeremy Siek	3a39729b58	new file [SVN r9488]	2001-03-08 16:33:40 +00:00
Dave Abrahams	096c961d9a	Patches for Intel C++ [SVN r9425]	2001-03-04 16:08:20 +00:00
Dave Abrahams	01fe04a6a2	Workaround for Borland [SVN r9424]	2001-03-04 16:07:11 +00:00
John Maddock	7ea4014993	Misc fixes that missed the last commit.. [SVN r9402]	2001-03-04 11:08:29 +00:00