This commit was manufactured by cvs2svn to create tag

'Version_1_30_0'.

[SVN r18026]

OptionalPointee.html

@@ -97,50 +97,22 @@ But boost::optional<T>, on the other hand, which is also a model of Option
 deep-copy and deep-relational semantics.<br>
 If generic code is written for this concept, it is important not to use relational
 operators directly because the semantics might be different depending on the actual type.<br>
-Still, the concept itsef can be used to define <i>deep</i> relational tests that can
+Still, the concept itsef can be used to define a <i>deep</i> equality-test that can
 be used in generic code with any type which models OptionalPointee:</p>
 <a name="equal"></a>
-<p><u>Equivalence relation:</u></p>
-<pre>template&lt;class OptionalPointee&gt;
+<pre>
+template&lt;class OptionalPointee&gt;
 inline
 bool equal_pointees ( OptionalPointee const&amp; x, OptionalPointee const&amp; y )
 {
   return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
 }
-template&lt;class OptionalPointee&gt;
-struct equal_pointees_t : std::binary_function&lt;OptionalPointee,OptionalPointee,bool&gt;
-{
-  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
-    { return equal_pointees(x,y) ; }
-} ;
 </pre>
-<p>The preceding generic function and function object have the following semantics:<br>
-If both <b>x</b> and <b>y</b> have valid pointees, it compares values via <code>(*x == *y)</code>.<br>
-If only one has a valid pointee, returns <code>false</code>.<br>
-If both have invalid pointees, returns <code>true</code>.</p>
-<a name="less"></a>
-<p><u>Less-than relation:</u></p>
-<pre>template&lt;class OptionalPointee&gt;
-inline
-bool less_pointees ( OptionalPointee const&amp; x, OptionalPointee const&amp; y )
-{
-  return !y ? false : ( !x ? true : (*x) < (*y) ) ;
-}
-template&lt;class OptionalPointee&gt;
-struct less_pointees_t : std::binary_function&lt;OptionalPointee,OptionalPointee,bool&gt;
-{
-  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
-    { return less_pointees(x,y) ; }
-} ;
-</pre>
-<p>The preceding generic function and function object have the following semantics:<br>
-If <b>y</b> has an invalid pointee, returns <code>false</code>.<br>
-Else, if <b>x</b> has an invalid pointee, returns <code>true</code>.<br>
-Else, ( <b>x</b> and <b>y</b> have valid pointees), compares values via <code>(*x &lt; 
-*y).</code></p>
-<p><br>
-All these functions and function 
-objects are is implemented in <a href="../../boost/utility/compare_pointees.hpp">compare_pointees.hpp</a></p>
+<p>The preceding generic function has the following semantics:<br>
+If both x and y have valid pointees, it compares pointee's values via (*x == *y).<br>
+If only one has a valid pointee, returns false.<br>
+If both have invalid pointees, returns true.</p>
+<p><code>equal_pointees()</code> is implemented in <a href="../../boost/optional.hpp">optional.hpp</a></p>
 <p>Notice that OptionalPointee does not imply aliasing (and optional&lt;&gt; for instance does not alias);
 so direct usage of relational operators with the implied aliasing of shallow semantics
 -as with pointers- should not be used with generic code written for this concept.</p>
@@ -155,4 +127,4 @@ based on the original concept developed by Augustus Saunders.
 </TD></TR></TABLE>
 
 </BODY>
-</HTML>
+</HTML>

base_from_member.html

@@ -64,12 +64,11 @@ public:
 </pre></blockquote>
 
 <p>This is undefined because C++'s initialization order mandates that
-the base class is initialized before the member it uses.  <a
-href="http://www.moocat.org">R. Samuel Klatchko</a> developed a way
-around this by using the initialization order in his favor.  Base
-classes are intialized in order of declaration, so moving the desired
-member to another base class, that is initialized before the desired
-base class, can ensure proper initialization.</p>
+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>
 
@@ -109,13 +108,7 @@ public:
 };
 </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>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,
@@ -136,21 +129,15 @@ class boost::base_from_member
 protected:
     MemberType  member;
 
-    base_from_member();
+    explicit  base_from_member();
 
     template&lt; typename T1 &gt;
     explicit  base_from_member( T1 x1 );
 
-    template&lt; typename T1, typename T2 &gt;
-    base_from_member( T1 x1, T2 x2 );
-
     //...
 
-    template&lt; typename T1, typename T2, typename T3, typename T4,
-     typename T5, typename T6, typename T7, typename T8, typename T9,
-     typename T10 &gt;
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7,
-     T8 x8, T9 x9, T10 x10 );
+    template&lt; typename T1, typename T2, typename T3 &gt;
+    explicit  base_from_member( T1 x1, T2 x2, T3 x3 );
 };
 </pre></blockquote>
 
@@ -165,7 +152,7 @@ for later base classes (or itself).</p>
 
 <p>There is a default constructor and several constructor member
 templates.  These constructor templates can take as many arguments
-(currently up to ten) as possible and pass them to a constructor of
+(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
@@ -326,9 +313,7 @@ with the exact pointer type used in <code>switcher</code>'s constructor.</p>
 	<dt><a href="../../people/ed_brey.htm">Ed Brey</a>
 	<dd>Suggested some interface changes.
 
-	<dt><a href="http://www.moocat.org">R. Samuel Klatchko</a> (<a
-	href="mailto:rsk@moocat.org">rsk@moocat.org</a>, <a
-	href="mailto:rsk@brightmail.com">rsk@brightmail.com</a>)
+	<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.
 
@@ -344,12 +329,13 @@ with the exact pointer type used in <code>switcher</code>'s constructor.</p>
 
 <hr>
 
-<p>Revised: 14 June 2003</p>
+<p>Revised: 22 August 2001</p>
 
-<p>Copyright 2001, 2003 Daryle Walker.  Use, modification, and distribution
-are subject to the Boost Software License, Version 1.0.  (See accompanying
-file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
-href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+<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>

base_from_member_test.cpp

@@ -1,19 +1,21 @@
 //  Boost test program for base-from-member class templates  -----------------//
 
-//  Copyright 2001, 2003 Daryle Walker.  Use, modification, and distribution are
-//  subject to the Boost Software License, Version 1.0.  (See accompanying file
-//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+//  (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/libs/utility/> for the library's home page.
+//  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
-//  14 Jun 2003  Adjusted code for Boost.Test changes (Daryle Walker)
 //  29 Aug 2001  Initial Version (Daryle Walker)
 
-#include <boost/test/minimal.hpp>  // for BOOST_CHECK, main
+#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/config.hpp>   // for BOOST_NO_MEMBER_TEMPLATES
+#include <boost/cstdlib.hpp>  // for boost::exit_success
 #include <boost/noncopyable.hpp>  // for boost::noncopyable
 
 #include <boost/utility/base_from_member.hpp>  // for boost::base_from_member
@@ -175,11 +177,11 @@ object_registrar  obj_reg;
 int
 test_main( int , char * [] )
 {
-    BOOST_CHECK( obj_reg.db_.empty() );
-    BOOST_CHECK( obj_reg.defrauders_in_.empty() );
-    BOOST_CHECK( obj_reg.defrauders_out_.empty() );
-    BOOST_CHECK( obj_reg.overeager_.empty() );
-    BOOST_CHECK( obj_reg.overkilled_.empty() );
+    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
     {
@@ -187,20 +189,20 @@ test_main( int , char * [] )
         using std::endl;
 
         bad_class  bc;
-        BOOST_CHECK( obj_reg.db_.size() == 3 );
-        BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
+        BOOST_TEST( obj_reg.db_.size() == 3 );
+        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
 
         good_class_1  gc1;
-        BOOST_CHECK( obj_reg.db_.size() == 6 );
-        BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
+        BOOST_TEST( obj_reg.db_.size() == 6 );
+        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
 
         good_class_2  gc2;
-        BOOST_CHECK( obj_reg.db_.size() == 11 );
-        BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
+        BOOST_TEST( obj_reg.db_.size() == 11 );
+        BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
 
-        BOOST_CHECK( obj_reg.defrauders_out_.empty() );
-        BOOST_CHECK( obj_reg.overeager_.empty() );
-        BOOST_CHECK( obj_reg.overkilled_.empty() );
+        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.
@@ -209,11 +211,11 @@ test_main( int , char * [] )
         cout << "Object 'gc2' is at " << &gc2 << '.' << endl;
     }
 
-    BOOST_CHECK( obj_reg.db_.empty() );
-    BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
-    BOOST_CHECK( obj_reg.defrauders_out_.size() == 1 );
-    BOOST_CHECK( obj_reg.overeager_.empty() );
-    BOOST_CHECK( obj_reg.overkilled_.empty() );
+    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;
 }

binary_search_test.cpp

@@ -14,7 +14,6 @@
 #include <list>
 #include <algorithm>
 #include <boost/detail/binary_search.hpp>
-#include <boost/detail/workaround.hpp>
 
 #if defined(__SGI_STL_PORT) ? defined(__SGI_STL_OWN_IOSTREAMS) : (!defined(__GNUC__) || __GNUC__ > 2)
 # define USE_SSTREAM
@@ -28,16 +27,7 @@
 
 namespace {
 
-// In order to get ADL to find the comparison operators defined below, they have
-struct mystring : std::string
-{
-    typedef std::string base;
-    
-    mystring(std::string const& x)
-        : base(x) {}
-};
-
-typedef std::vector<mystring> string_vector;
+typedef std::vector<std::string> string_vector;
 
 const std::size_t sequence_length = 1000;
 
@@ -84,21 +74,20 @@ struct cmp
     }
 };
 
-inline bool operator<(const mystring& x, const unsigned y)
+inline bool operator<(const std::string& x, const unsigned y)
 {
     return to_int(x) < y;
 }
 
-inline bool operator<(const unsigned y, const mystring& x)
+inline bool operator<(const unsigned y, const std::string& x)
 {
     return y < to_int(x);
 }
 
-template <class T>
-void sort_by_value(T& x);
+template <class T> void sort_by_value(T&);
 
-template <class T>
-void sort_by_value_(T& v, long)
+template <>
+void sort_by_value(std::vector<std::string>& v)
 {
     std::sort(v.begin(), v.end(), cmp());
 }
@@ -114,26 +103,28 @@ void random_sorted_sequence(T& seq)
     sort_by_value(seq);
 }
 
-template <class T, class A>
-void sort_by_value_(std::list<T,A>& l, int)
-{
-# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) && !defined(__SGI_STL_PORT)
+# if defined(BOOST_MSVC) && BOOST_MSVC < 1300 && !defined(__SGI_STL_PORT)
 // VC6's standard lib doesn't have a template member function for list::sort()
-    std::vector<T> seq;
-    seq.reserve(sequence_length);
-    std::copy(l.begin(), l.end(), std::back_inserter(seq));
-    sort_by_value(seq);
-    std::copy(seq.begin(), seq.end(), l.begin());
-# else
-    l.sort(cmp());
-# endif
-}
-
-template <class T>
-void sort_by_value(T& x)
+template <>
+void random_sorted_sequence(std::list<std::string>& result)
 {
-    (sort_by_value_)(x, 1);
+    std::vector<std::string> seq;
+    seq.reserve(sequence_length);
+    for (std::size_t i = 0; i < sequence_length; ++i)
+    {
+        push_back_random_number_string(seq);
+    }
+    sort_by_value(seq);
+    result.resize(seq.size());
+    std::copy(seq.begin(), seq.end(), result.begin());
 }
+#else
+template <>
+void sort_by_value(std::list<std::string>& l)
+{
+    l.sort(cmp());
+}
+# endif
 
 // A way to select the comparisons with/without a Compare parameter for testing.
 template <class Compare> struct searches
@@ -242,13 +233,13 @@ void test_loop(Sequence& x, Compare cmp, unsigned long test_count)
 
 int main()
 {
-    string_vector x;
+    std::vector<std::string> x;
     std::cout << "=== testing random-access iterators with <: ===\n";
     test_loop(x, no_compare(), 25);
     std::cout << "=== testing random-access iterators with compare: ===\n";
     test_loop(x, cmp(), 25);
     
-    std::list<mystring> y;
+    std::list<std::string> y;
     std::cout << "=== testing bidirectional iterators with <: ===\n";
     test_loop(y, no_compare(), 25);
     std::cout << "=== testing bidirectional iterators with compare: ===\n";

call_traits.htm

@@ -749,7 +749,7 @@ no claim as to its suitability for any purpose.</p>
 <p>Based on contributions by Steve Cleary, Beman Dawes, Howard
 Hinnant and John Maddock.</p>
 
-<p>Maintained by <a href="mailto:john@johnmaddock.co.uk">John
+<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

call_traits_test.cpp

@@ -1,10 +1,9 @@
-//  boost::compressed_pair test program   
+ // boost::compressed_pair test program   
     
-//  (C) Copyright John Maddock 2000. 
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-
+ //  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
+ //  distribute this software is granted provided this copyright notice appears   
+ //  in all copies. This software is provided "as is" without express or implied   
+ //  warranty, and with no claim as to its suitability for any purpose.   
 
 // standalone test program for <boost/call_traits.hpp>
 // 18 Mar 2002:

checked_delete_test.cpp

@@ -1,9 +1,12 @@
 //  Boost checked_delete test program  ---------------------------------------//
 
-//  Copyright Beman Dawes 2001.
-//  See accompanying license for terms and conditions of use.
+//  (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/libs/utility for documentation.
+//  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
 //  21 May 01  Initial version (Beman Dawes)
@@ -20,8 +23,9 @@ namespace
 
 int main()
 {
-    Incomplete * p = 0;
+    Incomplete * p;
     boost::checked_delete(p);          // should cause compile time error
-    boost::checked_array_delete(p);    // should cause compile time error
+    Incomplete ** pa;
+    boost::checked_array_delete(pa);   // should cause compile time error
     return 0;
 }   // main

compressed_pair.htm

@@ -87,7 +87,7 @@ no claim as to its suitability for any purpose.</p>
 <p>Based on contributions by Steve Cleary, Beman Dawes, Howard
 Hinnant and John Maddock.</p>
 
-<p>Maintained by <a href="mailto:john@johnmaddock.co.uk">John
+<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

compressed_pair_test.cpp

@@ -1,9 +1,9 @@
-//  boost::compressed_pair test program   
+ // boost::compressed_pair test program   
     
-//  (C) Copyright John Maddock 2000. 
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
+ //  (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and   
+ //  distribute this software is granted provided this copyright notice appears   
+ //  in all copies. This software is provided "as is" without express or implied   
+ //  warranty, and with no claim as to its suitability for any purpose.   
 
 // standalone test program for <boost/compressed_pair.hpp>
 // Revised 03 Oct 2000: 

counting_iterator.htm

@@ -0,0 +1,325 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<title>Counting Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+align="center" width="277" height="86">
+
+<h1>Counting Iterator Adaptor</h1>
+
+Defined in header
+<a href="../../boost/counting_iterator.hpp">boost/counting_iterator.hpp</a>
+
+<p>
+How would you fill up a vector with the numbers zero
+through one hundred using <a
+href="http://www.sgi.com/tech/stl/copy.html"><tt>std::copy()</tt></a>? The
+only iterator operation missing from builtin integer types is an
+<tt>operator*()</tt> that returns the current
+value of the integer.  The counting iterator adaptor adds this crucial piece of
+functionality to whatever type it wraps. One can use the
+counting iterator adaptor not only with integer types, but with any
+type that is <tt>Incrementable</tt> (see type requirements <a href="#requirements">below</a>).  The
+following <b>pseudo-code</b> shows the general idea of how the
+counting iterator is implemented.
+</p>
+
+<pre>
+  // inside a hypothetical counting_iterator class...
+  typedef Incrementable value_type;
+  value_type counting_iterator::operator*() const {
+    return this->base; // no dereference!
+  }
+</pre>
+
+All of the other operators of the counting iterator behave in the same
+fashion as the <tt>Incrementable</tt> base type.
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;class Incrementable&gt;
+  struct <a href="#counting_iterator_traits">counting_iterator_traits</a>;
+
+  template &lt;class Incrementable&gt;
+  struct <a href="#counting_iterator_generator">counting_iterator_generator</a>;
+
+  template &lt;class Incrementable&gt;
+  typename counting_iterator_generator&lt;Incrementable&gt;::type
+  <a href="#make_counting_iterator">make_counting_iterator</a>(Incrementable x);
+}
+</pre>
+
+<hr>
+
+<h2><a name="counting_iterator_generator">The Counting Iterator Type
+Generator</a></h2>
+
+The class template <tt>counting_iterator_generator&lt;Incrementable&gt;</tt> is a <a href="../../more/generic_programming.html#type_generator">type generator</a> for counting iterators.
+
+<pre>
+template &lt;class Incrementable&gt;
+class counting_iterator_generator
+{
+public:
+    typedef <a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt; type;
+};
+</pre>
+
+<h3>Example</h3>
+
+In this example we use the counting iterator generator to create a
+counting iterator, and count from zero to four.
+
+<pre>
+#include &lt;boost/config.hpp&gt;
+#include &lt;iostream&gt;
+#include &lt;boost/counting_iterator.hpp&gt;
+
+int main(int, char*[])
+{
+  // Example of using counting_iterator_generator
+  std::cout &lt;&lt; "counting from 0 to 4:" &lt;&lt; std::endl;
+  boost::counting_iterator_generator&lt;int&gt;::type first(0), last(4);
+  std::copy(first, last, std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+
+  // to be continued...
+</pre>
+The output from this part is:
+<pre>
+counting from 0 to 4:
+0 1 2 3 
+</pre>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><tt>Incrementable</tt></TD>
+<TD>The type being wrapped by the adaptor.</TD>
+</TR>
+
+</Table>
+
+<h3>Model of</h3>
+
+If the <tt>Incrementable</tt> type has all of the functionality of a
+<a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> except the <tt>operator*()</tt>, then the counting
+iterator will be a model of <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a>. If the <tt>Incrementable</tt> type has less
+functionality, then the counting iterator will have correspondingly
+less functionality.
+
+<h3><a name="requirements">Type Requirements</a></h3>
+
+The <tt>Incrementable</tt> type must be <a
+href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
+Constructible</a>, <a href="./CopyConstructible.html">Copy
+Constructible</a>, and <a href="./Assignable.html">Assignable</a>.
+Also, the <tt>Incrementable</tt> type must provide access to an
+associated <tt>difference_type</tt> and <tt>iterator_category</tt>
+through the <a
+href="#counting_iterator_traits"><tt>counting_iterator_traits</tt></a>
+class.
+
+<p>
+Furthermore, if you wish to create a counting iterator that is a <a
+href="http://www.sgi.com/tech/stl/ForwardIterator.html"> Forward
+Iterator</a>, then the following expressions must be valid:
+<pre>
+Incrementable i, j;
+++i         // pre-increment
+i == j      // operator equal
+</pre>
+If you wish to create a counting iterator that is a <a
+href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">
+Bidirectional Iterator</a>, then pre-decrement is also required:
+<pre>
+--i
+</pre>
+If you wish to create a counting iterator that is a <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html"> Random
+Access Iterator</a>, then these additional expressions are also required:
+<pre>
+<a href="#counting_iterator_traits">counting_iterator_traits</a>&lt;Incrementable&gt;::difference_type n;
+i += n
+n = i - j
+i < j
+</pre>
+
+
+
+<h3>Members</h3>
+
+The counting iterator type implements the member functions and
+operators required of the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> concept. In addition it has the following
+constructor:
+
+<pre>
+counting_iterator_generator::type(const Incrementable&amp; i)
+</pre>
+
+<p>
+<hr>
+<p>
+
+
+<h2><a name="make_counting_iterator">The Counting Iterator Object Generator</a></h2>
+
+<pre>
+template &lt;class Incrementable&gt;
+typename counting_iterator_generator&lt;Incrementable&gt;::type
+make_counting_iterator(Incrementable base);
+</pre>
+
+An <a href="../../more/generic_programming.html#object_generator">object
+generator</a> function that provides a convenient way to create counting
+iterators.<p>
+
+
+
+<h3>Example</h3>
+
+In this example we count from negative five to positive five, this
+time using the <tt>make_counting_iterator()</tt> function to save some
+typing.
+
+<pre>
+  // continuing from previous example...
+
+  std::cout &lt;&lt; "counting from -5 to 4:" &lt;&lt; std::endl;
+  std::copy(boost::make_counting_iterator(-5),
+	    boost::make_counting_iterator(5),
+	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+
+  // to be continued...
+</pre>
+The output from this part is:
+<pre>
+counting from -5 to 4:
+-5 -4 -3 -2 -1 0 1 2 3 4 
+</pre>
+
+In the next example we create an array of numbers, and then create a
+second array of pointers, where each pointer is the address of a
+number in the first array. The counting iterator makes it easy to do
+this since dereferencing a counting iterator that is wrapping an
+iterator over the array of numbers just returns a pointer to the
+current location in the array. We then use the <a
+href="./indirect_iterator.htm">indirect iterator adaptor</a> to print
+out the number in the array by accessing the numbers through the array
+of pointers.
+
+<pre>
+  // continuing from previous example...
+
+  const int N = 7;
+  std::vector&lt;int&gt; numbers;
+  // Fill "numbers" array with [0,N)
+  std::copy(boost::make_counting_iterator(0), boost::make_counting_iterator(N),
+	    std::back_inserter(numbers));
+
+  std::vector&lt;std::vector&lt;int&gt;::iterator&gt; pointers;
+
+  // Use counting iterator to fill in the array of pointers.
+  std::copy(boost::make_counting_iterator(numbers.begin()),
+	    boost::make_counting_iterator(numbers.end()),
+	    std::back_inserter(pointers));
+
+  // Use indirect iterator to print out numbers by accessing
+  // them through the array of pointers.
+  std::cout &lt;&lt; "indirectly printing out the numbers from 0 to " 
+	    &lt;&lt; N &lt;&lt; std::endl;
+  std::copy(boost::make_indirect_iterator(pointers.begin()),
+	    boost::make_indirect_iterator(pointers.end()),
+	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+</pre>
+The output is:
+<pre>
+indirectly printing out the numbers from 0 to 7
+0 1 2 3 4 5 6 
+</pre>
+
+<hr>
+
+<h2><a name="counting_iterator_traits">Counting Iterator Traits</a></h2>
+
+The counting iterator adaptor needs to determine the appropriate
+<tt>difference_type</tt> and <tt>iterator_category</tt> to use based on the
+<tt>Incrementable</tt> type supplied by the user.  The
+<tt>counting_iterator_traits</tt> class provides these types.  If the
+<tt>Incrementable</tt> type is an integral type or an iterator, these types
+will be correctly deduced by the <tt>counting_iterator_traits</tt> provided by
+the library. Otherwise, the user must specialize
+<tt>counting_iterator_traits</tt> for her type or add nested typedefs to
+her type to fulfill the needs of
+<a href="http://www.sgi.com/tech/stl/iterator_traits.html">
+<tt>std::iterator_traits</tt></a>.
+
+<p>The following pseudocode describes how the <tt>counting_iterator_traits</tt> are determined:
+
+<pre>
+template &lt;class Incrementable&gt;
+struct counting_iterator_traits
+{
+  if (numeric_limits&lt;Incrementable&gt::is_specialized) {
+    if (!numeric_limits&lt;Incrementable&gt::is_integer)
+       COMPILE_TIME_ERROR;
+
+    if (!numeric_limits&lt;Incrementable&gt::is_bounded
+        &amp;&amp; numeric_limits&lt;Incrementable&gt;::is_signed) {
+        typedef Incrementable difference_type;
+    }
+    else if (numeric_limits&lt;Incrementable&gt::is_integral) {
+        typedef <i>next-larger-signed-type-or-intmax_t</i> difference_type;
+    }
+    typedef std::random_access_iterator_tag iterator_category;   
+  } else {
+    typedef std::iterator_traits&lt;Incrementable&gt;::difference_type difference_type;
+    typedef std::iterator_traits&lt;Incrementable&gt;::iterator_category iterator_category;
+  }
+};
+</pre>
+
+<p>The italicized sections above are implementation details, but it is important
+to know that the <tt>difference_type</tt> for integral types is selected so that
+it can always represent the difference between two values if such a built-in
+integer exists. On platforms with a working <tt>std::numeric_limits</tt>
+implementation, the <tt>difference_type</tt> for any variable-length signed
+integer type <tt>T</tt> is <tt>T</tt> itself.
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->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;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>
+<!--  LocalWords:  html charset alt gif hpp incrementable const namespace htm
+ -->
+<!--  LocalWords:  struct  typename iostream int Siek CopyConstructible pre
+ -->
+

counting_iterator_example.cpp

@@ -5,18 +5,17 @@
 
 
 #include <boost/config.hpp>
-#include <algorithm>
 #include <iostream>
 #include <iterator>
 #include <vector>
-#include <boost/iterator/counting_iterator.hpp>
-#include <boost/iterator/indirect_iterator.hpp>
+#include <boost/counting_iterator.hpp>
+#include <boost/iterator_adaptors.hpp>
 
 int main(int, char*[])
 {
   // Example of using counting_iterator_generator
   std::cout << "counting from 0 to 4:" << std::endl;
-  boost::counting_iterator<int> first(0), last(4);
+  boost::counting_iterator_generator<int>::type first(0), last(4);
   std::copy(first, last, std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
 
@@ -28,25 +27,23 @@ int main(int, char*[])
   std::cout << std::endl;
 
   // Example of using counting iterator to create an array of pointers.
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-  const
-#endif 
-      int N = 7;
+  const int N = 7;
   std::vector<int> numbers;
   // Fill "numbers" array with [0,N)
-  std::copy(
-      boost::make_counting_iterator(0)
-      , boost::make_counting_iterator(N)
-      , std::back_inserter(numbers));
+  std::copy(boost::make_counting_iterator(0), boost::make_counting_iterator(N),
+            std::back_inserter(numbers));
 
   std::vector<std::vector<int>::iterator> pointers;
 
   // Use counting iterator to fill in the array of pointers.
   // causes an ICE with MSVC6
+#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
   std::copy(boost::make_counting_iterator(numbers.begin()),
             boost::make_counting_iterator(numbers.end()),
             std::back_inserter(pointers));
+#endif 
 
+#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
   // Use indirect iterator to print out numbers by accessing
   // them through the array of pointers.
   std::cout << "indirectly printing out the numbers from 0 to " 
@@ -55,6 +52,6 @@ int main(int, char*[])
             boost::make_indirect_iterator(pointers.end()),
             std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
-  
+#endif
   return 0;
 }

counting_iterator_test.cpp

@@ -0,0 +1,269 @@
+// (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears in
+// all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org for most recent version including documentation.
+//
+// Revision History
+// 16 Feb 2001  Added a missing const. Made the tests run (somewhat) with
+//              plain MSVC again. (David Abrahams)
+// 11 Feb 2001  #if 0'd out use of counting_iterator on non-numeric types in
+//              MSVC without STLport, so that the other tests may proceed
+//              (David Abrahams)
+// 04 Feb 2001  Added use of iterator_tests.hpp (David Abrahams)
+// 28 Jan 2001  Removed not_an_iterator detritus (David Abrahams)
+// 24 Jan 2001  Initial revision (David Abrahams)
+
+#include <boost/config.hpp>
+#ifdef BOOST_MSVC
+# pragma warning(disable:4786) // identifier truncated in debug info
+#endif
+
+#include <boost/pending/iterator_tests.hpp>
+#include <boost/counting_iterator.hpp>
+#include <boost/detail/iterator.hpp>
+#include <iostream>
+#include <climits>
+#include <iterator>
+#include <stdlib.h>
+#ifndef __BORLANDC__
+# include <boost/tuple/tuple.hpp>
+#endif 
+#include <vector>
+#include <list>
+#include <cassert>
+#ifndef BOOST_NO_LIMITS
+# include <limits>
+#endif
+#ifndef BOOST_NO_SLIST
+# include <slist>
+#endif
+
+template <class T> struct is_numeric
+{
+    enum { value = 
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+        std::numeric_limits<T>::is_specialized
+#else
+        // Causes warnings with GCC, but how else can I detect numeric types at
+        // compile-time?
+        (boost::is_convertible<int,T>::value &&
+         boost::is_convertible<T,int>::value)
+#endif
+    };
+};
+
+// Special tests for RandomAccess CountingIterators.
+template <class CountingIterator>
+void category_test(
+    CountingIterator start,
+    CountingIterator finish,
+    std::random_access_iterator_tag)
+{
+    typedef typename
+        boost::detail::iterator_traits<CountingIterator>::difference_type
+        difference_type;
+    difference_type distance = boost::detail::distance(start, finish);
+
+    // Pick a random position internal to the range
+    difference_type offset = (unsigned)rand() % distance;
+    assert(offset >= 0);
+    CountingIterator internal = start;
+    std::advance(internal, offset);
+
+    // Try some binary searches on the range to show that it's ordered
+    assert(std::binary_search(start, finish, *internal));
+
+    // #including tuple crashed borland, so I had to give up on tie().
+    std::pair<CountingIterator,CountingIterator> xy(
+        std::equal_range(start, finish, *internal));
+    CountingIterator x = xy.first, y = xy.second;
+    
+    assert(boost::detail::distance(x, y) == 1);
+
+    // Show that values outside the range can't be found
+    assert(!std::binary_search(start, boost::prior(finish), *finish));
+
+    // Do the generic random_access_iterator_test
+    typedef typename CountingIterator::value_type value_type;
+    std::vector<value_type> v;
+    for (value_type z = *start; z != *finish; ++z)
+        v.push_back(z);
+    if (v.size() >= 2)
+    {
+        // Note that this test requires a that the first argument is
+        // dereferenceable /and/ a valid iterator prior to the first argument
+        boost::random_access_iterator_test(start + 1, v.size() - 1, v.begin() + 1);
+    }
+}
+
+// Special tests for bidirectional CountingIterators
+template <class CountingIterator>
+void category_test(CountingIterator start, CountingIterator finish, std::bidirectional_iterator_tag)
+{
+    if (finish != start
+        && finish != boost::next(start)
+        && finish != boost::next(boost::next(start)))
+    {
+        // Note that this test requires a that the first argument is
+        // dereferenceable /and/ a valid iterator prior to the first argument
+        boost::bidirectional_iterator_test(boost::next(start), boost::next(*start), boost::next(boost::next(*start)));
+    }
+}
+
+template <class CountingIterator>
+void category_test(CountingIterator start, CountingIterator finish, std::forward_iterator_tag)
+{
+    if (finish != start && finish != boost::next(start))
+        boost::forward_iterator_test(start, *start, boost::next(*start));
+}
+
+template <class CountingIterator>
+void test_aux(CountingIterator start, CountingIterator finish)
+{
+    typedef typename CountingIterator::iterator_category category;
+    typedef typename CountingIterator::value_type value_type;
+
+    // If it's a RandomAccessIterator we can do a few delicate tests
+    category_test(start, finish, category());
+    
+    // Okay, brute force...
+    for (CountingIterator p = start; p != finish && boost::next(p) != finish; ++p)
+    {
+        assert(boost::next(*p) == *boost::next(p));
+    }
+
+    // prove that a reference can be formed to these values
+    typedef typename CountingIterator::value_type value;
+    const value* q = &*start;
+    (void)q; // suppress unused variable warning
+}
+
+template <class Incrementable>
+void test(Incrementable start, Incrementable finish)
+{
+    test_aux(boost::make_counting_iterator(start), boost::make_counting_iterator(finish));
+}
+
+template <class Integer>
+void test_integer(Integer* = 0) // default arg works around MSVC bug
+{
+    Integer start = 0;
+    Integer finish = 120;
+    test(start, finish);
+}
+
+template <class Container>
+void test_container(Container* = 0)  // default arg works around MSVC bug
+{
+    Container c(1 + (unsigned)rand() % 1673);
+
+    const typename Container::iterator start = c.begin();
+    
+    // back off by 1 to leave room for dereferenceable value at the end
+    typename Container::iterator finish = start;
+    std::advance(finish, c.size() - 1);
+    
+    test(start, finish);
+
+    typedef typename Container::const_iterator const_iterator;
+    test(const_iterator(start), const_iterator(finish));
+}
+
+class my_int1 {
+public:
+  my_int1() { }
+  my_int1(int x) : m_int(x) { }
+  my_int1& operator++() { ++m_int; return *this; }
+  bool operator==(const my_int1& x) const { return m_int == x.m_int; }
+private:
+  int m_int;
+};
+
+namespace boost {
+  template <>
+  struct counting_iterator_traits<my_int1> {
+    typedef std::ptrdiff_t difference_type;
+    typedef std::forward_iterator_tag iterator_category;
+  };
+}
+
+class my_int2 {
+public:
+  typedef void value_type;
+  typedef void pointer;
+  typedef void reference;
+  typedef std::ptrdiff_t difference_type;
+  typedef std::bidirectional_iterator_tag iterator_category;
+
+  my_int2() { }
+  my_int2(int x) : m_int(x) { }
+  my_int2& operator++() { ++m_int; return *this; }
+  my_int2& operator--() { --m_int; return *this; }
+  bool operator==(const my_int2& x) const { return m_int == x.m_int; }
+private:
+  int m_int;
+};
+
+class my_int3 {
+public:
+  typedef void value_type;
+  typedef void pointer;
+  typedef void reference;
+  typedef std::ptrdiff_t difference_type;
+  typedef std::random_access_iterator_tag iterator_category;
+
+  my_int3() { }
+  my_int3(int x) : m_int(x) { }
+  my_int3& operator++() { ++m_int; return *this; }
+  my_int3& operator+=(std::ptrdiff_t n) { m_int += n; return *this; }
+  std::ptrdiff_t operator-(const my_int3& x) const { return m_int - x.m_int; }
+  my_int3& operator--() { --m_int; return *this; }
+  bool operator==(const my_int3& x) const { return m_int == x.m_int; }
+  bool operator!=(const my_int3& x) const { return m_int != x.m_int; }
+  bool operator<(const my_int3& x) const { return m_int < x.m_int; }
+private:
+  int m_int;
+};
+
+int main()
+{
+    // Test the built-in integer types.
+    test_integer<char>();
+    test_integer<unsigned char>();
+    test_integer<signed char>();
+    test_integer<wchar_t>();
+    test_integer<short>();
+    test_integer<unsigned short>();
+    test_integer<int>();
+    test_integer<unsigned int>();
+    test_integer<long>();
+    test_integer<unsigned long>();
+#if defined(BOOST_HAS_LONG_LONG)
+    test_integer<long long>();
+    test_integer<unsigned long long>();
+#endif
+
+   // wrapping an iterator or non-built-in integer type causes an INTERNAL
+   // COMPILER ERROR in MSVC without STLport. I'm clueless as to why.
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1200 || defined(__SGI_STL_PORT)
+    // Test user-defined type.
+    test_integer<my_int1>();
+    test_integer<my_int2>();
+    test_integer<my_int3>();
+    
+   // Some tests on container iterators, to prove we handle a few different categories
+    test_container<std::vector<int> >();
+    test_container<std::list<int> >();
+# ifndef BOOST_NO_SLIST
+    test_container<BOOST_STD_EXTENSION_NAMESPACE::slist<int> >();
+# endif
+
+    // Also prove that we can handle raw pointers.
+    int array[2000];
+    test(boost::make_counting_iterator(array), boost::make_counting_iterator(array+2000-1));
+#endif
+    std::cout << "test successful " << std::endl;
+    return 0;
+}

current_function_test.cpp

@@ -1,6 +1,4 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
+#if defined(_MSC_VER) && !defined(__ICL)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

enable_if.html

@@ -1,388 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
-            "http://www.w3.org/TR/REC-html40/loose.dtd">
-<HTML>
-<HEAD><TITLE>enable_if</TITLE>
-
-<META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<META name="GENERATOR" content="Microsoft FrontPage 5.0">
-</HEAD>
-<BODY >
-<!--HEVEA command line is: hevea -nosymb -noiso -pedantic -v enable_if_docs_for_boost.tex -->
-<!--HTMLHEAD-->
-<!--ENDHTML-->
-<!--PREFIX <ARG ></ARG>-->
-<!--CUT DEF section 1 -->
-<BR>
-<BR>
-
-
-<h1>
-<img border="0" src="../../c++boost.gif" align="center" width="277" height="86">enable_if</h1>
-<BR>
-<BR>
-Copyright 2003 Jaakko J&auml;rvi, Jeremiah Willcock, Andrew Lumsdaine.<BR>
-<BR>
-<!--TOC section Introduction-->
-
-<H2><A NAME="htoc1">1</A>&nbsp;&nbsp;Introduction</H2><!--SEC END -->
-
-<A NAME="introduction"></A>
-The <TT>enable_if</TT> family of templates is a set of tools to allow a function template or a class template specialization 
-to include or exclude itself from a set of matching functions or specializations
-based on properties of its template arguments. 
-For example, one can define function templates that
-are only enabled for, and thus only match, an arbitrary set of types
-defined by a traits class. The <TT>enable_if</TT> templates can also be
-applied to enable class template specializations. Applications of
-<TT>enable_if</TT> are discussed in length
-in&nbsp;[<A HREF="#jarvi:03:cuj_arbitrary_overloading"><CITE>1</CITE></A>] and&nbsp;[<A HREF="#jarvi:03:c++typeclasses"><CITE>2</CITE></A>].<BR>
-<BR>
-<!--TOC subsection Synopsis-->
-
-<H3><A NAME="htoc2">1.1</A>&nbsp;&nbsp;Synopsis</H3><!--SEC END -->
-
-<A NAME="sec:synopsis"></A>
-<PRE>namespace boost {
-  template &lt;class Cond, class T = void&gt; struct enable_if;
-  template &lt;class Cond, class T = void&gt; struct disable_if;
-  template &lt;class Cond, class T&gt; struct lazy_enable_if;
-  template &lt;class Cond, class T&gt; struct lazy_disable_if;
-
-  template &lt;bool B, class T = void&gt; struct enable_if_c;
-  template &lt;bool B, class T = void&gt; struct disable_if_c;
-  template &lt;bool B, class T&gt; struct lazy_enable_if_c;
-  template &lt;bool B, class T&gt; struct lazy_disable_if_c;
-}
-</PRE>
-<!--TOC subsection Background-->
-
-<H3><A NAME="htoc3">1.2</A>&nbsp;&nbsp;Background</H3><!--SEC END -->
-
-<A NAME="sec:background"></A>
-Sensible operation of template function overloading in C++ relies
-on the <EM>SFINAE</EM> (substitution-failure-is-not-an-error)
-principle&nbsp;[<A HREF="#vandevoorde2002:templates"><CITE>3</CITE></A>]: if an invalid argument
-or return type is formed during the instantiation of a function
-template, the instantiation is removed from the overload resolution
-set instead of causing a compilation error. The following example, 
-taken from&nbsp;[<A HREF="#jarvi:03:cuj_arbitrary_overloading"><CITE>1</CITE></A>],
-demonstrates why this is important:
-<PRE>int negate(int i) { return -i; }
-
-template &lt;class F&gt;
-typename F::result_type negate(const F&amp; f) { return -f(); }
-
-</PRE>
-Suppose the compiler encounters the call <TT>negate(1)</TT>. The first
-definition is obviously a better match, but the compiler must
-nevertheless consider (and instantiate the prototypes) of both
-definitions to find this out. Instantiating the latter definition with
-<TT>F</TT> as <TT>int</TT> would result in:
-<PRE>int::result_type negate(const int&amp;);
-
-</PRE>
-where the return type is invalid. If this was an error, adding an unrelated function template 
-(that was never called) could break otherwise valid code.
-Due to the SFINAE principle the above example is not, however, erroneous. 
-The latter definition of <TT>negate</TT> is simply removed from the overload resolution set.<BR>
-<BR>
-The <TT>enable_if</TT> templates are tools for controlled creation of the SFINAE
-conditions.<BR>
-<BR>
-<!--TOC section The <TT>enable_if</TT> templates-->
-
-<H2><A NAME="htoc4">2</A>&nbsp;&nbsp;The <TT>enable_if</TT> templates</H2><!--SEC END -->
-
-<A NAME="enable_if"></A>
-The names of the <TT>enable_if</TT> templates have three parts: an optional <TT>lazy_</TT> tag, 
-either <TT>enable_if</TT> or <TT>disable_if</TT>, and an optional <TT>_c</TT> tag.
-All eight combinations of these parts are supported.
-The meaning of the <TT>lazy_</TT> tag is described in Section&nbsp;<A HREF="#sec:enable_if_lazy">3.3</A>.
-The second part of the name indicates whether a true condition argument should 
-enable or disable the current overload.
-The third part of the name indicates whether the condition argument is a <TT>bool</TT> value 
-(<TT>_c</TT> suffix), or a type containing a static <TT>bool</TT> constant named <TT>value</TT> (no suffix).
-The latter version interoperates with Boost.MPL. <BR>
-<BR>
-The definitions of <TT>enable_if_c</TT> and <TT>enable_if</TT> are as follows (we use <TT>enable_if</TT> templates 
-unqualified but they are in the <TT>boost</TT> namespace).
-<PRE>template &lt;bool B, class T = void&gt;
-struct enable_if_c {
-  typedef T type;
-};
-
-template &lt;class T&gt;
-struct enable_if_c&lt;false, T&gt; {};
-
-template &lt;class Cond, class T = void&gt;
-struct enable_if : public enable_if_c&lt;Cond::value, T&gt; {};
-
-</PRE>
-An instantiation of the <TT>enable_if_c</TT> template with the parameter
-<TT>B</TT> as <TT>true</TT> contains a member type <TT>type</TT>, defined
-to be <TT>T</TT>. If <TT>B</TT> is
-<TT>false</TT>, no such member is defined. Thus 
-<TT>enable_if_c&lt;B, T&gt;::type</TT> is either a valid or an invalid type
-expression, depending on the value of <TT>B</TT>.
-When valid, <TT>enable_if_c&lt;B, T&gt;::type</TT> equals <TT>T</TT>.
-The <TT>enable_if_c</TT> template can thus be used for controlling when functions are considered for
-overload resolution and when they are not. 
-For example, the following function is defined for all arithmetic types (according to the
-classification of the <A HREF="http://www.boost.org/libs/type_traits">Boost type_traits library</A>):
-<PRE>template &lt;class T&gt;
-typename enable_if_c&lt;boost::is_arithmetic&lt;T&gt;::value, T&gt;::type 
-foo(T t) { return t; }
-
-</PRE>
-The <TT>disable_if_c</TT> template is provided as well, and has the
-same functionality as <TT>enable_if_c</TT> except for the negated condition. The following
-function is enabled for all non-arithmetic types.
-<PRE>template &lt;class T&gt;
-typename disable_if_c&lt;boost::is_arithmetic&lt;T&gt;::value, T&gt;::type 
-bar(T t) { return t; }
-
-</PRE>
-For easier syntax in some cases and interoperation with Boost.MPL we provide versions of
-the <TT>enable_if</TT> templates taking any type with a <TT>bool</TT> member constant named 
-<TT>value</TT> as the condition argument.
-The MPL <TT>bool_</TT>, <TT>and_</TT>, <TT>or_</TT>, and <TT>not_</TT> templates are likely to be 
-useful for creating such types. Also, the traits classes in the Boost.Type_traits library 
-follow this convention. 
-For example, the above example function <TT>foo</TT> can be alternatively written as:
-<PRE>template &lt;class T&gt;
-typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
-foo(T t) { return t; }
-
-</PRE>
-<!--TOC section Using <TT>enable_if</TT>-->
-
-<H2><A NAME="htoc5">3</A>&nbsp;&nbsp;Using <TT>enable_if</TT></H2><!--SEC END -->
-
-<A NAME="sec:using_enable_if"></A>
-The <TT>enable_if</TT> templates are defined in
-<TT>boost/utility/enable_if.hpp</TT>, which is included by <TT>boost/utility.hpp</TT>.<BR>
-<BR>
-The <TT>enable_if</TT> template can be used either as the return type, or as an 
-extra argument. For example, the <TT>foo</TT> function in the previous section could also be written
-as:
-<PRE>template &lt;class T&gt;
-T foo(T t, typename enable_if&lt;boost::is_arithmetic&lt;T&gt; &gt;::type* dummy = 0); 
-
-</PRE>Hence, an extra parameter of type <TT>void*</TT> is added, but it is given 
-a default value to keep the parameter hidden from client code.
-Note that the second template argument was not given to <TT>enable_if</TT>, as the default 
-<TT>void</TT> gives the desired behavior.<BR>
-<BR>
-Whether to write the enabler as an argument or within the return type is
-largely a matter of taste, but for certain functions, only one
-alternative is possible:
-<UL><LI>
-Operators have a fixed number of arguments, thus <TT>enable_if</TT> must be used in the return type.
-<LI>Constructors and destructors do not have a return type; an extra argument is the only option.
-<LI>There does not seem to be a way to specify an enabler for a conversion operator. Converting constructors,
-however, can have enablers as extra default arguments.
-</UL>
-<!--TOC subsection Enabling template class specializations-->
-
-<H3><A NAME="htoc6">3.1</A>&nbsp;&nbsp;Enabling template class specializations</H3><!--SEC END -->
-
-<A NAME="sec:enable_if_classes"></A>
-Class template specializations can be enabled or disabled with <TT>enable_if</TT>.
-One extra template parameter needs to be added for the enabler expressions.
-This parameter has the default value <TT>void</TT>.
-For example:
-<PRE>template &lt;class T, class Enable = void&gt; 
-class A { ... };
-
-template &lt;class T&gt;
-class A&lt;T, typename enable_if&lt;is_integral&lt;T&gt; &gt;::type&gt; { ... };
-
-template &lt;class T&gt;
-class A&lt;T, typename enable_if&lt;is_float&lt;T&gt; &gt;::type&gt; { ... };
-
-</PRE>Instantiating <TT>A</TT> with any integral type matches the first specialization,
-whereas any floating point type matches the second one. All other types
-match the primary template.
-The condition can be any compile-time boolean expression that depends on the 
-template arguments of the class.
-Note that again, the second argument to <TT>enable_if</TT> is not needed; the default (<TT>void</TT>) 
-is the correct value.<BR>
-<BR>
-<!--TOC subsection Overlapping enabler conditions-->
-
-<H3><A NAME="htoc7">3.2</A>&nbsp;&nbsp;Overlapping enabler conditions</H3><!--SEC END -->
-
-<A NAME="sec:overlapping_conditions"></A>
-Once the compiler has examined the enabling conditions and included the
-function into the overload resolution set, normal C++ overload resolution 
-rules are used to select the best matching function.
-In particular, there is no ordering between enabling conditions.
-Function templates with enabling conditions that are not mutually exclusive can 
-lead to ambiguities. For example:
-<PRE>template &lt;class T&gt;
-typename enable_if&lt;boost::is_integral&lt;T&gt;, void&gt;::type 
-foo(T t) {}
-
-template &lt;class T&gt;
-typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, void&gt;::type 
-foo(T t) {}
-
-</PRE>
-All integral types are also arithmetic. Therefore, say, for the call <TT>foo(1)</TT>,
-both conditions are true and both functions are thus in the overload resolution set.
-They are both equally good matches and thus ambiguous.
-Of course, more than one enabling condition can be simultaneously true as long as 
-other arguments disambiguate the functions.<BR>
-<BR>
-The above discussion applies to using <TT>enable_if</TT> in class template
-partial specializations as well.<BR>
-<BR>
-<!--TOC subsection Lazy <TT>enable_if</TT>-->
-
-<H3><A NAME="htoc8">3.3</A>&nbsp;&nbsp;Lazy <TT>enable_if</TT></H3><!--SEC END -->
-
-<A NAME="sec:enable_if_lazy"></A>
-In some cases it is necessary to avoid instantiating part of a
-function signature unless an enabling condition is true. For example:
-<PRE>template &lt;class T, class U&gt; class mult_traits;
-
-template &lt;class T, class U&gt;
-typename enable_if&lt;is_multipliable&lt;T, U&gt;, typename mult_traits&lt;T, U&gt;::type&gt;::type
-operator*(const T&amp; t, const U&amp; u) { ... }
-
-</PRE>Assume the class template <TT>mult_traits</TT> is a traits class defining 
-the resulting type of a multiplication operator. The <TT>is_multipliable</TT> traits
-class specifies for which types to enable the operator. Whenever
-<TT>is_multipliable&lt;A, B&gt;::value</TT> is <TT>true</TT> for some types <TT>A</TT> and <TT>B</TT>,
-then <TT>mult_traits&lt;A, B&gt;::type</TT> is defined.<BR>
-<BR>
-Now, trying to invoke (some other overload) of <TT>operator*</TT> with, say, operand types <TT>C</TT> and <TT>D</TT> 
-for which <TT>is_multipliable&lt;C, D&gt;::value</TT> is <TT>false</TT> 
-and <TT>mult_traits&lt;C, D&gt;::type</TT> is not defined is an error on some compilers. 
-The SFINAE principle is not applied because
-the invalid type occurs as an argument to another template. The <TT>lazy_enable_if</TT> 
-and <TT>lazy_disable_if</TT> templates (and their <TT>_c</TT> versions) can be used in such
-situations:
-<PRE>template&lt;class T, class U&gt;
-typename lazy_enable_if&lt;is_multipliable&lt;T, U&gt;, mult_traits&lt;T, U&gt; &gt;::type
-operator*(const T&amp; t, const U&amp; u) { ... }
-
-</PRE>The second argument of <TT>lazy_enable_if</TT> must be a class type
-that defines a nested type named <TT>type</TT> whenever the first
-parameter (the condition) is true.<BR>
-<BR>
-<!--TOC paragraph Note-->
-
-<H5>Note</H5><!--SEC END -->
-
-Referring to one member type or static constant in a traits class
-causes all of the members (type and static constant) of that
-specialization to be instantiated. Therefore, if your traits classes
-can sometimes contain invalid types, you should use two distinct
-templates for describing the conditions and the type mappings. In the
-above example, <TT>is_multipliable&lt;T, U&gt;::value</TT> defines when
-<TT>mult_traits&lt;T, U&gt;::type</TT> is valid.<BR>
-<BR>
-<!--TOC subsection Compiler workarounds-->
-
-<H3><A NAME="htoc9">3.4</A>&nbsp;&nbsp;Compiler workarounds</H3><!--SEC END -->
-
-<A NAME="sec:workarounds"></A>
-Some compilers flag functions as ambiguous if the only distinguishing factor is a different 
-condition in an enabler (even though the functions could never be ambiguous). For example,
-some compilers (e.g. GCC 3.2) diagnose the following two functions as ambiguous:
-<PRE>template &lt;class T&gt;
-typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
-foo(T t);
-
-template &lt;class T&gt;
-typename disable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
-foo(T t);
-
-</PRE>Two workarounds can be applied:
-<UL><LI>
-Use an extra dummy parameter which disambiguates the functions. Use a default value for
-it to hide the parameter from the caller. For example:
-<PRE>template &lt;class T&gt; struct dummy { dummy(int) {} };
-
-template &lt;class T&gt;
-typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
-foo(T t, dummy&lt;0&gt; = 0);
-
-template &lt;class T&gt;
-typename disable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
-foo(T t, dummy&lt;1&gt; = 0);
-</PRE><BR>
-<BR>
-<LI>Define the functions in different namespaces and bring them into a common
-namespace with <TT>using</TT> declarations:
-<PRE>namespace A {
-  template &lt;class T&gt;
-  typename enable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
-  foo(T t);
-}
-
-namespace B {
-  template &lt;class T&gt;
-  typename disable_if&lt;boost::is_arithmetic&lt;T&gt;, T&gt;::type 
-  foo(T t);
-}
-
-using A::foo;
-using B::foo;
-
-</PRE>
-Note that the second workaround above cannot be used for member
-templates. On the other hand, operators do not accept extra arguments,
-which makes the first workaround unusable. As the net effect,
-neither of the workarounds are of assistance for templated operators that
-need to be defined as member functions (assignment and
-subscript operators).
-</UL>
-<!--TOC section Acknowledgements-->
-
-<H2><A NAME="htoc10">4</A>&nbsp;&nbsp;Acknowledgements</H2><!--SEC END -->
-
-We are grateful to Howard Hinnant, Jason Shirk, Paul Mensonides, and Richard
-Smith whose findings have influenced the library.<BR>
-<BR>
-<!--TOC section References-->
-
-<H2>References</H2><!--SEC END -->
-<DL COMPACT=compact><DT><A NAME="jarvi:03:cuj_arbitrary_overloading"><FONT COLOR=purple>[1]</FONT></A><DD>
-Jaakko J&auml;rvi, Jeremiah Willcock, Howard Hinnant, and Andrew Lumsdaine.
-Function overloading based on arbitrary properties of types.
-<EM>C/C++ Users Journal</EM>, 21(6):25--32, June 2003.<BR>
-<BR>
-<DT><A NAME="jarvi:03:c++typeclasses"><FONT COLOR=purple>[2]</FONT></A><DD>
-Jaakko J&auml;rvi, Jeremiah Willcock, and Andrew Lumsdaine.
-Concept-controlled polymorphism.
-In Frank Pfennig and Yannis Smaragdakis, editors, <EM>Generative
- Programming and Component Engineering</EM>, volume 2830 of <EM>LNCS</EM>, pages
- 228--244. Springer Verlag, September 2003.<BR>
-<BR>
-<DT><A NAME="vandevoorde2002:templates"><FONT COLOR=purple>[3]</FONT></A><DD>
-David Vandevoorde and Nicolai&nbsp;M. Josuttis.
-<EM>C++ Templates: The Complete Guide</EM>.
-Addison-Wesley, 2002.</DL>
-
-
-
-
-
-<hr></hr>
-
-<B>Contributed by:</B> <BR>
-Jaakko J&auml;rvi, Jeremiah Willcock and Andrew Lumsdaine<BR>
-<EM>{jajarvi|jewillco|lums}@osl.iu.edu</EM><BR>
-Indiana University<BR>
-Open Systems Lab
-<!--HTMLFOOT-->
-<!--ENDHTML-->
-<!--FOOTER-->
-<HR SIZE=2>
-<BLOCKQUOTE><EM>This document was translated from L<sup>A</sup>T<sub>E</sub>X by
-</EM><A HREF="http://pauillac.inria.fr/~maranget/hevea/index.html"><EM>H<FONT SIZE=2><sup>E</sup></FONT>V<FONT SIZE=2><sup>E</sup></FONT>A</EM></A><EM>.
-</EM></BLOCKQUOTE>
-</BODY>
-</HTML>

enable_if_constructors.cpp

@@ -1,62 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 <20> The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//    Authors: Jaakko J<>rvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-#include <boost/test/minimal.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits.hpp>
-
-using boost::enable_if;
-using boost::disable_if;
-using boost::is_arithmetic;
-
-struct container {
-  bool my_value;
-
-  template <class T>
-  container(const T&, const typename enable_if<is_arithmetic<T>, T>::type * = 0):
-  my_value(true) {}
-
-  template <class T>
-  container(const T&, const typename disable_if<is_arithmetic<T>, T>::type * = 0):
-  my_value(false) {}
-};
-
-// example from Howard Hinnant (tests enable_if template members of a templated class)
-template <class charT>
-struct xstring
-{
-  template <class It>
-  xstring(It begin, It end, typename 
-          disable_if<is_arithmetic<It> >::type* = 0)
-    : data(end-begin) {}
-  
-  int data;
-};
-
-
-int test_main(int, char*[])
-{
- 
-  BOOST_CHECK(container(1).my_value);
-  BOOST_CHECK(container(1.0).my_value);
-
-  BOOST_CHECK(!container("1").my_value);  
-  BOOST_CHECK(!container(static_cast<void*>(0)).my_value);  
-
-  char sa[] = "123456";
-  BOOST_CHECK(xstring<char>(sa, sa+6).data == 6);
-
-
-  return 0;
-}
-

enable_if_dummy_arg_disambiguation.cpp

@@ -1,46 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 <20> The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//    Authors: Jaakko J<>rvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-#include <boost/test/minimal.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-
-using boost::enable_if;
-using boost::disable_if;
-using boost::is_arithmetic;
-
-template <int N> struct dummy {
-  dummy(int) {};
-};
-
-template<class T>
-typename enable_if<is_arithmetic<T>, bool>::type
-arithmetic_object(T t, dummy<0> = 0) { return true; }
-
-template<class T>
-typename disable_if<is_arithmetic<T>, bool>::type
-arithmetic_object(T t, dummy<1> = 0) { return false; }
-
-
-int test_main(int, char*[])
-{
- 
-  BOOST_CHECK(arithmetic_object(1));
-  BOOST_CHECK(arithmetic_object(1.0));
-
-  BOOST_CHECK(!arithmetic_object("1"));  
-  BOOST_CHECK(!arithmetic_object(static_cast<void*>(0)));  
-
-  return 0;
-}
-

enable_if_lazy.cpp

@@ -1,82 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 <20> The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//    Authors: Jaakko J<>rvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-#include <boost/test/minimal.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-using boost::enable_if_c;
-using boost::lazy_enable_if_c;
-
-// This class provides a reduced example of a traits class for
-// computing the result of multiplying two types.  The member typedef
-// 'type' in this traits class defines the return type of this
-// operator.  The return type member is invalid unless both arguments
-// for mult_traits are values that mult_traits expects (ints in this
-// case).  This kind of situation may arise if a traits class only
-// makes sense for some set of types, not all C++ types.
-
-template <class T> struct is_int {
-  BOOST_STATIC_CONSTANT(bool, value = (boost::is_same<T, int>::value));
-};
-
-template <class T, class U>
-struct mult_traits {
-  typedef typename T::does_not_exist type;
-};
-
-template <>
-struct mult_traits<int, int> {
-  typedef int type;
-};
-
-
-// Next, a forwarding function mult() is defined.  It is enabled only
-// when both arguments are of type int.  The first version, using
-// non-lazy enable_if_c does not work.
-
-#if 0
-template <class T, class U>
-typename enable_if_c<
-  is_int<T>::value && is_int<U>::value,
-  typename mult_traits<T, U>::type
->::type
-mult(const T& x, const U& y) {return x * y;}
-#endif
-
-// A correct version uses lazy_enable_if_c.
-// This template removes compiler errors from invalid code used as an
-// argument to enable_if_c.
-
-#if 1
-template <class T, class U>
-typename lazy_enable_if_c<
-  is_int<T>::value && is_int<U>::value,
-  mult_traits<T, U> 
->::type
-mult(const T& x, const U& y) {return x * y;}
-#endif
-
-double mult(int i, double d) { return (double)i * d; }
-
-int test_main(int, char*[])
-{
-
-
-  BOOST_CHECK(mult(1, 2) == 2);
-
-  BOOST_CHECK(mult(1, 3.0) == 3.0);
-
-  return 0;
-}
-

enable_if_lazy_test.cpp

@@ -1,100 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 <20> The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//    Authors: Jaakko J<>rvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-// Testing all variations of lazy_enable_if.
-
-#include <boost/test/minimal.hpp>
-#include <boost/mpl/not.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-using boost::lazy_enable_if;
-using boost::lazy_disable_if;
-
-using boost::lazy_enable_if_c;
-using boost::lazy_disable_if_c;
-
-
-template <class T>
-struct is_int_or_double {
-  BOOST_STATIC_CONSTANT(bool, 
-    value = (boost::is_same<T, int>::value || 
-             boost::is_same<T, double>::value));
-};
-
-template <class T>
-struct some_traits {
-  typedef typename T::does_not_exist type;
-};
-
-template <>
-struct some_traits<int> {
-  typedef bool type;
-};
-
-template <>
-struct some_traits<double> {
-  typedef bool type;
-};
-
-template <class T>
-struct make_bool {
-  typedef bool type;
-};
-
-template <>
-struct make_bool<int> {};
-
-template <>
-struct make_bool<double> {};
-
-namespace A {
-
-  template<class T>
-  typename lazy_enable_if<is_int_or_double<T>, some_traits<T> >::type
-  foo(T t) { return true; }
-
-  template<class T>
-  typename lazy_enable_if_c<is_int_or_double<T>::value, some_traits<T> >::type
-  foo2(T t) { return true; }
-}
-
-namespace B {
-  template<class T>
-  typename lazy_disable_if<is_int_or_double<T>, make_bool<T> >::type
-  foo(T t) { return false; }
-
-  template<class T>
-  typename lazy_disable_if_c<is_int_or_double<T>::value, make_bool<T> >::type
-  foo2(T t) { return false; }
-}
-
-int test_main(int, char*[])
-{
-  using namespace A;
-  using namespace B;
-  BOOST_CHECK(foo(1));
-  BOOST_CHECK(foo(1.0));
-
-  BOOST_CHECK(!foo("1"));  
-  BOOST_CHECK(!foo(static_cast<void*>(0)));  
-
-  BOOST_CHECK(foo2(1));
-  BOOST_CHECK(foo2(1.0));
-
-  BOOST_CHECK(!foo2("1"));  
-  BOOST_CHECK(!foo2(static_cast<void*>(0)));  
-
-  return 0;
-}
-

enable_if_member_templates.cpp

@@ -1,43 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 <20> The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//    Authors: Jaakko J<>rvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-#include <boost/test/minimal.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-
-using boost::enable_if;
-using boost::disable_if;
-using boost::is_arithmetic;
-
-struct container {
-  template <class T>
-  typename enable_if<is_arithmetic<T>, bool>::type
-  arithmetic_object(const T&, const int* /* disambiguate */ = 0) {return true;}
-
-  template <class T>
-  typename disable_if<is_arithmetic<T>, bool>::type
-  arithmetic_object(const T&) {return false;}
-};
-
-int test_main(int, char*[])
-{
- 
-  BOOST_CHECK(container().arithmetic_object(1));
-  BOOST_CHECK(container().arithmetic_object(1.0));
-
-  BOOST_CHECK(!container().arithmetic_object("1"));  
-  BOOST_CHECK(!container().arithmetic_object(static_cast<void*>(0)));  
-
-  return 0;
-}
-

enable_if_namespace_disambiguation.cpp

@@ -1,47 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 <20> The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//    Authors: Jaakko J<>rvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-#include <boost/test/minimal.hpp>
-#include <boost/mpl/not.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-
-using boost::enable_if;
-using boost::mpl::not_;
-using boost::is_arithmetic;
-
-namespace A {
-  template<class T>
-  typename enable_if<is_arithmetic<T>, bool>::type
-  arithmetic_object(T t) { return true; }
-}
-
-namespace B {
-  template<class T>
-  typename enable_if<not_<is_arithmetic<T> >, bool>::type
-  arithmetic_object(T t) { return false; }
-}
-
-int test_main(int, char*[])
-{
-  using namespace A;
-  using namespace B;
-  BOOST_CHECK(arithmetic_object(1));
-  BOOST_CHECK(arithmetic_object(1.0));
-
-  BOOST_CHECK(!arithmetic_object("1"));  
-  BOOST_CHECK(!arithmetic_object(static_cast<void*>(0)));  
-
-  return 0;
-}
-

enable_if_no_disambiguation.cpp

@@ -1,43 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 <20> The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//    Authors: Jaakko J<>rvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-#include <boost/test/minimal.hpp>
-#include <boost/mpl/not.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-
-using boost::mpl::not_;
-using boost::enable_if;
-using boost::is_arithmetic;
-
-template<class T>
-typename enable_if<is_arithmetic<T>, bool>::type
-arithmetic_object(T t) { return true; }
-
-template<class T>
-typename enable_if<not_<is_arithmetic<T> >, bool>::type
-arithmetic_object(T t) { return false; }
-
-
-int test_main(int, char*[])
-{
- 
-  BOOST_CHECK(arithmetic_object(1));
-  BOOST_CHECK(arithmetic_object(1.0));
-
-  BOOST_CHECK(!arithmetic_object("1"));  
-  BOOST_CHECK(!arithmetic_object(static_cast<void*>(0)));  
-
-  return 0;
-}
-

enable_if_partial_specializations.cpp

@@ -1,67 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 <20> The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//    Authors: Jaakko J<>rvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-#include <boost/test/minimal.hpp>
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-
-using boost::enable_if_c;
-using boost::disable_if_c;
-using boost::enable_if;
-using boost::disable_if;
-using boost::is_arithmetic;
-
-template <class T, class Enable = void>
-struct tester;
-
-template <class T>
-struct tester<T, typename enable_if_c<is_arithmetic<T>::value>::type> {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <class T>
-struct tester<T, typename disable_if_c<is_arithmetic<T>::value>::type> {
-  BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T, class Enable = void>
-struct tester2;
-
-template <class T>
-struct tester2<T, typename enable_if<is_arithmetic<T> >::type> {
-  BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <class T>
-struct tester2<T, typename disable_if<is_arithmetic<T> >::type> {
-  BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-int test_main(int, char*[])
-{
- 
-  BOOST_CHECK(tester<int>::value);
-  BOOST_CHECK(tester<double>::value);
-
-  BOOST_CHECK(!tester<char*>::value);
-  BOOST_CHECK(!tester<void*>::value);
-
-  BOOST_CHECK(tester2<int>::value);
-  BOOST_CHECK(tester2<double>::value);
-
-  BOOST_CHECK(!tester2<char*>::value);
-  BOOST_CHECK(!tester2<void*>::value);
-
-  return 0;
-}
-

filter_iterator.htm

@@ -0,0 +1,273 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<title>Filter Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+align="center" width="277" height="86">
+
+<h1>Filter Iterator Adaptor</h1>
+
+Defined in header
+<a href="../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
+
+
+<p>
+The filter iterator adaptor creates a view of an iterator range in
+which some elements of the range are skipped over. A <a
+href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>
+function object controls which elements are skipped. When the
+predicate is applied to an element, if it returns <tt>true</tt> then
+the element is retained and if it returns <tt>false</tt> then the
+element is skipped over.
+
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;class Predicate, class BaseIterator, ...&gt;
+  class filter_iterator_generator;
+
+  template &lt;class Predicate, class BaseIterator&gt;
+  typename filter_iterator_generator&lt;Predicate, BaseIterator&gt;::type
+  make_filter_iterator(BaseIterator first, BaseIterator last, const Predicate& p = Predicate());
+}
+</pre>
+
+<hr>
+
+<h2><a name="filter_iterator_generator">The Filter Iterator Type
+Generator</a></h2>
+
+The class <tt>filter_iterator_generator</tt> is a helper class whose
+purpose is to construct a filter iterator type.  The template
+parameters for this class are the <tt>Predicate</tt> function object
+type and the <tt>BaseIterator</tt> type that is being wrapped.  In
+most cases the associated types for the wrapped iterator can be
+deduced from <tt>std::iterator_traits</tt>, but in some situations the
+user may want to override these types, so there are also template
+parameters for each of the iterator's associated types.
+
+<pre>
+template &lt;class Predicate, class BaseIterator,
+          class Value, class Reference, class Pointer, class Category, class Distance>
+class filter_iterator_generator
+{
+public:
+  typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt;</tt> type; // the resulting filter iterator type 
+}
+</pre>
+
+
+<h3>Example</h3>
+
+The following example uses filter iterator to print out all the
+positive integers in an array. 
+
+<pre>
+struct is_positive_number {
+  bool operator()(int x) { return 0 &lt; x; }
+};
+int main() {
+  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
+  const int N = sizeof(numbers)/sizeof(int);
+
+  typedef boost::filter_iterator_generator&lt;is_positive_number, int*, int&gt;::type FilterIter;
+  is_positive_number predicate;
+  FilterIter::policies_type policies(predicate, numbers + N);
+  FilterIter filter_iter_first(numbers, policies);
+  FilterIter filter_iter_last(numbers + N, policies);
+
+  std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+  return 0;
+}
+</pre>
+The output is:
+<pre>
+4 5 8
+</pre>
+
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><a href="http://www.sgi.com/tech/stl/Predicate.html"><tt>Predicate</tt></a></TD>
+<TD>The function object that determines which elements are retained and which elements are skipped.
+</TR>
+
+<TR>
+<TD><tt>BaseIterator</tt></TD>
+<TD>The iterator type being wrapped. This type must at least be a model
+ of the <a href="http://www.sgi.com/tech/stl/InputIterator">InputIterator</a> concept.</TD>
+</TR>
+
+<TR>
+<TD><tt>Value</tt></TD>
+<TD>The <tt>value_type</tt> of the resulting iterator,
+unless const. If const, a conforming compiler strips constness for the
+<tt>value_type</tt>. Typically the default for this parameter is the
+appropriate type<a href="#1">[1]</a>.<br> <b>Default:</b>
+<tt>std::iterator_traits&lt;BaseIterator&gt;::value_type</TD>
+</TR>
+
+<TR>
+<TD><tt>Reference</tt></TD>
+<TD>The <tt>reference</tt> type of the resulting iterator, and in
+particular, the result type of <tt>operator*()</tt>. Typically the default for
+this parameter is the appropriate type.<br> <b>Default:</b> If
+<tt>Value</tt> is supplied, <tt>Value&amp;</tt> is used. Otherwise
+<tt>std::iterator_traits&lt;BaseIterator&gt;::reference</tt> is
+used.</TD>
+</TR>
+
+<TR>
+<TD><tt>Pointer</tt></TD>
+<TD>The <tt>pointer</tt> type of the resulting iterator, and in
+ particular, the result type of <tt>operator->()</tt>. 
+ Typically the default for
+this parameter is the appropriate type.<br>
+<b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
+otherwise <tt>std::iterator_traits&lt;BaseIterator&gt;::pointer</tt>.</TD>
+</TR>
+
+
+<TR>
+<TD><tt>Category</tt></TD>
+<TD>The <tt>iterator_category</tt> type for the resulting iterator.
+Typically the
+default for this parameter is the appropriate type. If you override
+this parameter, do not use <tt>bidirectional_iterator_tag</tt>
+because filter iterators can not go in reverse.<br>
+<b>Default:</b> <tt>std::iterator_traits&lt;BaseIterator&gt;::iterator_category</tt></TD>
+</TR>
+
+<TR>
+<TD><tt>Distance</tt></TD>
+<TD>The <tt>difference_type</tt> for the resulting iterator. Typically the default for
+this parameter is the appropriate type.<br>
+<b>Default:</b> <tt>std::iterator_traits&lt;BaseIterator&gt;::difference_type</TD>
+</TR>
+
+</table>
+
+
+<h3>Model of</h3>
+
+The filter iterator adaptor (the type
+<tt>filter_iterator_generator<...>::type</tt>) may be a model of <a
+href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a> or <a
+href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>
+depending on the adapted iterator type.
+
+
+<h3>Members</h3>
+
+The filter iterator type implements all of the member functions and
+operators required of the <a
+href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>
+concept.  In addition it has the following constructor:
+
+<pre>filter_iterator_generator::type(const BaseIterator& it, const Policies& p = Policies())</pre>
+
+<p>
+The policies type has only one public function, which is its constructor:
+
+<pre>filter_iterator_generator::policies_type(const Predicate& p, const BaseIterator& end)</pre>
+
+<p>
+<hr>
+<p>
+
+<h2><a name="make_filter_iterator">The Make Filter Iterator Function</a></h2>
+
+<pre>
+template &lt;class Predicate, class BaseIterator&gt;
+typename filter_generator&lt;Predicate, BaseIterator&gt;::type
+make_filter_iterator(BaseIterator first, BaseIterator last, const Predicate& p = Predicate())
+</pre>
+
+This function provides a convenient way to create filter iterators.
+
+<h3>Example</h3>
+
+In this example we print out all numbers in the array that are
+greater than negative two.
+
+<pre>
+int main()
+{
+  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
+  const int N = sizeof(numbers)/sizeof(int);
+
+  std::copy(boost::make_filter_iterator(numbers, numbers + N, 
+					std::bind2nd(std::greater<int>(), -2)),
+	    boost::make_filter_iterator(numbers + N, numbers + N, 
+					std::bind2nd(std::greater<int>(), -2)),
+	    std::ostream_iterator<int>(std::cout, " "));
+  std::cout << std::endl;
+
+}
+</pre>
+The output is:
+<pre>
+0 -1 4 5 8 
+</pre>
+
+<p>
+In the next example we print the positive numbers using the
+<tt>make_filter_iterator()</tt> function.
+
+<pre>
+struct is_positive_number {
+  bool operator()(int x) { return 0 &lt; x; }
+};
+int main()
+{
+  int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
+  const int N = sizeof(numbers)/sizeof(int);
+
+  std::copy(boost::make_filter_iterator&lt;is_positive_number&gt;(numbers, numbers + N),
+	    boost::make_filter_iterator&lt;is_positive_number&gt;(numbers + N, numbers + N),
+	    std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+  return 0;
+}
+</pre>
+The output is:
+<pre>
+4 5 8
+</pre>
+
+
+<h3>Notes</h3>
+
+<a name="1">[1]</a> If the compiler does not support partial
+specialization and the wrapped iterator type is a builtin pointer then
+the <tt>Value</tt> type must be explicitly specified (don't use the
+default).
+
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->09 Mar 2001<!--webbot bot="Timestamp" endspan i-checksum="14894" --></p>
+<p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
+modify, sell and distribute this document is granted provided this copyright
+notice appears in all copies. This document is provided &quot;as is&quot;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>

filter_iterator_example.cpp

@@ -11,7 +11,7 @@
 #include <algorithm>
 #include <functional>
 #include <iostream>
-#include <boost/iterator/filter_iterator.hpp>
+#include <boost/iterator_adaptors.hpp>
 
 struct is_positive_number {
   bool operator()(int x) { return 0 < x; }
@@ -22,7 +22,13 @@ int main()
   int numbers_[] = { 0, -1, 4, -3, 5, 8, -2 };
   const int N = sizeof(numbers_)/sizeof(int);
   
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+  // Assume there won't be proper iterator traits for pointers. This
+  // is just a wrapper for int* which has the right traits.
+  typedef boost::iterator_adaptor<int*, boost::default_iterator_policies, int> base_iterator;
+#else
   typedef int* base_iterator;
+#endif
   base_iterator numbers(numbers_);
   
   // Example using make_filter_iterator()
@@ -31,30 +37,23 @@ int main()
             std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
 
-  // Example using filter_iterator
-  typedef boost::filter_iterator<is_positive_number, base_iterator>
+  // Example using filter_iterator_generator
+  typedef boost::filter_iterator_generator<is_positive_number, base_iterator, int>::type
     FilterIter;
-  
   is_positive_number predicate;
-  FilterIter filter_iter_first(predicate, numbers, numbers + N);
-  FilterIter filter_iter_last(predicate, numbers + N, numbers + N);
+  FilterIter::policies_type policies(predicate, numbers + N);
+  FilterIter filter_iter_first(numbers, policies);
+  FilterIter filter_iter_last(numbers + N, policies);
 
   std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
 
   // Another example using make_filter_iterator()
-  std::copy(
-      boost::make_filter_iterator(
-          std::bind2nd(std::greater<int>(), -2)
-        , numbers, numbers + N)
-            
-    , boost::make_filter_iterator(
-          std::bind2nd(std::greater<int>(), -2)
-        , numbers + N, numbers + N)
-      
-    , std::ostream_iterator<int>(std::cout, " ")
-  );
-  
+  std::copy(boost::make_filter_iterator(numbers, numbers + N, 
+                                        std::bind2nd(std::greater<int>(), -2)),
+            boost::make_filter_iterator(numbers + N, numbers + N, 
+                                        std::bind2nd(std::greater<int>(), -2)),
+            std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
   
   

fun_out_iter_example.cpp

@@ -15,18 +15,12 @@
 
 #include <boost/function_output_iterator.hpp>
 
-struct string_appender
-{
-    string_appender(std::string& s)
-        : m_str(&s)
-    {}
-    
-    void operator()(const std::string& x) const
-    {
-        *m_str += x;
-    }
-
-    std::string* m_str;
+struct string_appender {
+  string_appender(std::string& s) : m_str(s) { }
+  void operator()(const std::string& x) const {
+    m_str += x;
+  }
+  std::string& m_str;
 };
 
 int main(int, char*[])

function_output_iterator.htm

@@ -0,0 +1,169 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+
+<html>
+<head>
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+    <meta name="ProgId" content="FrontPage.Editor.Document">
+
+    <title>Function Output Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+        
+    <img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
+    "center" width="277" height="86"> 
+
+    <h1>Function Output Iterator Adaptor</h1>
+    Defined in header <a href=
+    "../../boost/function_output_iterator.hpp">boost/function_output_iterator.hpp</a> 
+
+    <p>The function output iterator adaptor makes it easier to create
+    custom output iterators. The adaptor takes a <a
+    href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
+    Function</a> and creates a model of <a
+    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
+    Iterator</a>. Each item assigned to the output iterator is passed
+    as an argument to the unary function.  The motivation for this
+    iterator is that creating a C++ Standard conforming output
+    iterator is non-trivial, particularly because the proper
+    implementation usually requires a proxy object. On the other hand,
+    creating a function (or function object) is much simpler.
+
+    <h2>Synopsis</h2>
+
+    <blockquote>
+<pre>
+namespace boost {
+  template &lt;class UnaryFunction&gt;
+  class function_output_iterator;
+
+  template &lt;class UnaryFunction&gt;
+  function_output_iterator&lt;UnaryFunction&gt;
+  make_function_output_iterator(const UnaryFunction&amp; f = UnaryFunction())
+}
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    
+    In this example we create an output iterator that appends
+    each item onto the end of a string, using the <tt>string_appender</tt>
+    function. 
+
+    <blockquote>
+<pre>
+#include &lt;iostream&gt;
+#include &lt;string&gt;
+#include &lt;vector&gt;
+
+#include &lt;boost/function_output_iterator.hpp&gt;
+
+struct string_appender {
+  string_appender(std::string&amp; s) : m_str(s) { }
+  void operator()(const std::string&amp; x) const {
+    m_str += x;
+  }
+  std::string&amp; m_str;
+};
+
+int main(int, char*[])
+{
+  std::vector&lt;std::string&gt; x;
+  x.push_back("hello");
+  x.push_back(" ");
+  x.push_back("world");
+  x.push_back("!");
+
+  std::string s = "";
+  std::copy(x.begin(), x.end(), 
+            boost::make_function_output_iterator(string_appender(s)));
+  
+  std::cout &lt;&lt; s &lt;&lt; std::endl;
+
+  return 0;
+}
+</pre>
+    </blockquote>
+
+    <hr>
+
+    <h2><a name="function_output_iterator">The Function Output Iterator Class</a></h2>
+
+    <blockquote>
+<pre>
+template &lt;class UnaryFunction&gt;
+class function_output_iterator;
+</pre>
+    </blockquote>
+
+    The <tt>function_output_iterator</tt> class creates an <a
+    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
+    Iterator</a> out of a
+    <a href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
+    Function</a>. Each item assigned to the output iterator is passed
+    as an argument to the unary function.
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>UnaryFunction</tt> 
+
+        <td>The function type being wrapped. The return type of the
+        function is not used, so it can be <tt>void</tt>.  The
+        function must be a model of <a
+        href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
+        Function</a>.</td>
+    </table>
+
+    <h3>Concept Model</h3>
+    The function output iterator class is a model of <a
+    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
+    Iterator</a>.
+
+    <h2>Members</h3>
+    The function output iterator implements the member functions
+    and operators required of the <a
+    href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
+    Iterator</a> concept. In addition it has the following constructor:
+<pre>
+explicit function_output_iterator(const UnaryFunction& f = UnaryFunction())
+</pre>
+   <br>    
+    <br>
+
+    <hr>
+    <h2><a name="make_function_output_iterator">The Function Output Iterator Object
+    Generator</a></h2>
+
+    The <tt>make_function_output_iterator()</tt> function provides a
+    more convenient way to create function output iterator objects. The
+    function saves the user the trouble of explicitly writing out the
+    iterator types. If the default argument is used, the function
+    type must be provided as an explicit template argument.
+
+    <blockquote>
+<pre>
+template &lt;class UnaryFunction&gt;
+function_output_iterator&lt;UnaryFunction&gt;
+make_function_output_iterator(const UnaryFunction&amp; f = UnaryFunction())
+</pre>
+    </blockquote>
+
+    <hr>
+
+    <p>&copy; Copyright Jeremy Siek 2001. Permission to copy, use,
+    modify, sell and distribute this document is granted provided this
+    copyright notice appears in all copies. This document is provided
+    "as is" without express or implied warranty, and with no claim as
+    to its suitability for any purpose.
+
+</body>
+</html>

include/boost/call_traits.hpp

@@ -1,10 +1,9 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
+//  (C) Copyright Boost.org 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.
 
+//  See http://www.boost.org/libs/utility/call_traits.htm for Documentation.
 //  See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
 //  for full copyright notices.
 

include/boost/checked_delete.hpp

@@ -1,10 +1,8 @@
 #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
 #define BOOST_CHECKED_DELETE_HPP_INCLUDED
 
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#if _MSC_VER >= 1020
+#pragma once
 #endif
 
 //
@@ -12,8 +10,6 @@
 //
 //  Copyright (c) 1999, 2000, 2001, 2002 boost.org
 //  Copyright (c) 2002, 2003 Peter Dimov
-//  Copyright (c) 2003 Daniel Frey
-//  Copyright (c) 2003 Howard Hinnant
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
@@ -30,16 +26,13 @@ namespace boost
 
 template<class T> inline void checked_delete(T * x)
 {
-    // intentionally complex - simplification causes regressions
-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
-    (void) sizeof(type_must_be_complete);
+    typedef char type_must_be_complete[sizeof(T)];
     delete x;
 }
 
 template<class T> inline void checked_array_delete(T * x)
 {
-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
-    (void) sizeof(type_must_be_complete);
+    typedef char type_must_be_complete[sizeof(T)];
     delete [] x;
 }
 
@@ -50,7 +43,6 @@ template<class T> struct checked_deleter
 
     void operator()(T * x) const
     {
-        // boost:: disables ADL
         boost::checked_delete(x);
     }
 };

include/boost/compressed_pair.hpp

@@ -1,10 +1,9 @@
-//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
+//  (C) Copyright Boost.org 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.
 
+//  See http://www.boost.org for most recent version including documentation.
 //  See boost/detail/compressed_pair.hpp and boost/detail/ob_compressed_pair.hpp
 //  for full copyright notices.
 

include/boost/current_function.hpp

@@ -1,10 +1,8 @@
 #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
 #define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
 
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#if _MSC_VER >= 1020
+#pragma once
 #endif
 
 //
@@ -29,7 +27,7 @@ namespace detail
 inline void current_function_helper()
 {
 
-#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600))
+#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000))
 
 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
 
@@ -37,10 +35,6 @@ inline void current_function_helper()
 
 # define BOOST_CURRENT_FUNCTION __FUNCSIG__
 
-#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
-
-# define BOOST_CURRENT_FUNCTION __FUNCTION__
-
 #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
 
 # define BOOST_CURRENT_FUNCTION __FUNC__

include/boost/detail/call_traits.hpp

@@ -1,9 +1,10 @@
 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
+//  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.
 
 // call_traits: defines typedefs for function usage
 // (see libs/utility/call_traits.htm)
@@ -21,10 +22,13 @@
 #ifndef BOOST_CONFIG_HPP
 #include <boost/config.hpp>
 #endif
-#include <cstddef>
 
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/is_pointer.hpp>
+#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
+#include <boost/type_traits/arithmetic_traits.hpp>
+#endif
+#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
+#include <boost/type_traits/composite_traits.hpp>
+#endif
 
 namespace boost{
 
@@ -121,7 +125,7 @@ struct call_traits<T&const volatile>
    typedef T& param_type;  // hh removed const
 };
 #endif
-#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+#ifndef __SUNPRO_CC
 template <typename T, std::size_t N>
 struct call_traits<T [N]>
 {

include/boost/detail/compressed_pair.hpp

@@ -1,16 +1,14 @@
 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
+//  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.
 
 // compressed_pair: pair that "compresses" empty members
 // (see libs/utility/compressed_pair.htm)
 //
-// JM changes 25 Jan 2004:
-// For the case where T1 == T2 and both are empty, then first() and second()
-// should return different objects.
 // JM changes 25 Jan 2000:
 // Removed default arguments from compressed_pair_switch to get
 // C++ Builder 4 to accept them
@@ -21,11 +19,15 @@
 #define BOOST_DETAIL_COMPRESSED_PAIR_HPP
 
 #include <algorithm>
-
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/is_empty.hpp>
-#include <boost/type_traits/is_same.hpp>
+#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
+#include <boost/type_traits/object_traits.hpp>
+#endif
+#ifndef BOOST_SAME_TRAITS_HPP
+#include <boost/type_traits/same_traits.hpp>
+#endif
+#ifndef BOOST_CALL_TRAITS_HPP
 #include <boost/call_traits.hpp>
+#endif
 
 namespace boost
 {
@@ -271,21 +273,20 @@ namespace details
 
       compressed_pair_imp() {}
 
-      compressed_pair_imp(first_param_type x, second_param_type y)
-         : first_type(x), m_second(y) {}
+      compressed_pair_imp(first_param_type x, second_param_type)
+         : first_type(x) {}
 
       compressed_pair_imp(first_param_type x)
-         : first_type(x), m_second(x) {}
+         : first_type(x) {}
 
       first_reference       first()       {return *this;}
       first_const_reference first() const {return *this;}
 
-      second_reference       second()       {return m_second;}
-      second_const_reference second() const {return m_second;}
+      second_reference       second()       {return *this;}
+      second_const_reference second() const {return *this;}
 
       void swap(::boost::compressed_pair<T1,T2>&) {}
    private:
-      T2 m_second;
    };
 
    // 5    T1 == T2 and are not empty:   //JM

include/boost/detail/ob_call_traits.hpp

@@ -1,9 +1,10 @@
 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
+//  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.
 //
 //  Crippled version for crippled compilers:
 //  see libs/utility/call_traits.htm

include/boost/detail/ob_compressed_pair.hpp

@@ -1,9 +1,10 @@
 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/utility for most recent version including documentation.
+//  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.
 //  see libs/utility/compressed_pair.hpp
 //
 /* Release notes:
@@ -292,24 +293,22 @@ public:
    typedef typename call_traits<second_type>::const_reference second_const_reference;
 
             compressed_pair_4() : T1() {}
-            compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {}
+            compressed_pair_4(first_param_type x, second_param_type) : T1(x) {}
    // only one single argument constructor since T1 == T2
-   explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {}
+   explicit compressed_pair_4(first_param_type x) : T1(x) {}
    compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)
-      : T1(x.first()), m_second(x.second()) {}
+      : T1(x.first()){}
 
    first_reference       first()       { return *this; }
    first_const_reference first() const { return *this; }
 
-   second_reference       second()       { return m_second; }
-   second_const_reference second() const { return m_second; }
+   second_reference       second()       { return *this; }
+   second_const_reference second() const { return *this; }
 
    void swap(compressed_pair_4& y)
    {
       // no need to swap empty base classes:
    }
-private:
-   T2 m_second;
 };
 
 // T1 == T2, not empty

include/boost/generator_iterator.hpp

@@ -14,63 +14,57 @@
 #ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
 #define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
 
-#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator_adaptors.hpp>
 #include <boost/ref.hpp>
 
 namespace boost {
 
 template<class Generator>
-class generator_iterator
-  : public iterator_facade<
-        generator_iterator<Generator>
-      , typename Generator::result_type
-      , single_pass_traversal_tag
-      , typename Generator::result_type const&
-    >
+class generator_iterator_policies
 {
-    typedef iterator_facade<
-        generator_iterator<Generator>
-      , typename Generator::result_type
-      , single_pass_traversal_tag
-      , typename Generator::result_type const&
-    > super_t;
-    
- public:
-    generator_iterator() {}
-    generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}
+public:
+    generator_iterator_policies() { }
 
-    void increment()
-    {
-        m_value = (*m_g)();
+    template<class Base>
+    void initialize(Base& base) {
+      m_value = (*base)();
     }
 
+    // The Iter template argument is necessary for compatibility with a MWCW
+    // bug workaround
+    template <class IteratorAdaptor>
+    void increment(IteratorAdaptor& iter) {
+      m_value = (*iter.base())();
+    }
+
+    template <class IteratorAdaptor>
     const typename Generator::result_type&
-    dereference() const
-    {
-        return m_value;
-    }
+    dereference(const IteratorAdaptor&) const
+        { return m_value; }
 
-    bool equal(generator_iterator const& y) const
-    {
-        return this->m_g == y.m_g && this->m_value == y.m_value;
-    }
+    template <class IteratorAdaptor1, class IteratorAdaptor2>
+    bool equal(const IteratorAdaptor1& x, const IteratorAdaptor2& y) const
+        { return x.base() == y.base() &&
+            x.policies().m_value == y.policies().m_value; }
 
- private:
-    Generator* m_g;
-    typename Generator::result_type m_value;
+private:
+  typename Generator::result_type m_value;
 };
 
 template<class Generator>
 struct generator_iterator_generator
 {
-  typedef generator_iterator<Generator> type;
+  typedef iterator_adaptor<Generator*, generator_iterator_policies<Generator>,
+    typename Generator::result_type, const typename Generator::result_type&,
+    const typename Generator::result_type*, std::input_iterator_tag,
+    long>       type;
 };
 
 template <class Generator>
-inline generator_iterator<Generator>
+inline typename generator_iterator_generator<Generator>::type
 make_generator_iterator(Generator & gen)
 {
-  typedef generator_iterator<Generator> result_t;
+  typedef typename generator_iterator_generator<Generator>::type result_t;
   return result_t(&gen);
 }
 

include/boost/next_prior.hpp

@@ -8,14 +8,9 @@
 
 //  See http://www.boost.org/libs/utility for documentation.
 
-//  Revision History
-//  13 Dec 2003  Added next(x, n) and prior(x, n) (Daniel Walker)
-
 #ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
 #define BOOST_NEXT_PRIOR_HPP_INCLUDED
 
-#include <iterator>
-
 namespace boost {
 
 //  Helper functions for classes like bidirectional iterators not supporting
@@ -24,30 +19,15 @@ namespace boost {
 //  Usage:
 //    const std::list<T>::iterator p = get_some_iterator();
 //    const std::list<T>::iterator prev = boost::prior(p);
-//    const std::list<T>::iterator next = boost::next(prev, 2);
 
 //  Contributed by Dave Abrahams
 
 template <class T>
 inline T next(T x) { return ++x; }
 
-template <class T, class Distance>
-inline T next(T x, Distance n)
-{
-    std::advance(x, n);
-    return x;
-}
-
 template <class T>
 inline T prior(T x) { return --x; }
 
-template <class T, class Distance>
-inline T prior(T x, Distance n)
-{
-    std::advance(x, -n);
-    return x;
-}
-
 } // namespace boost
 
 #endif  // BOOST_NEXT_PRIOR_HPP_INCLUDED

include/boost/operators.hpp

@@ -78,10 +78,9 @@
 
 #include <boost/config.hpp>
 #include <boost/iterator.hpp>
-#include <boost/detail/workaround.hpp>
 
 #if defined(__sgi) && !defined(__GNUC__)
-#   pragma set woff 1234
+#pragma set woff 1234
 #endif
 
 #if defined(BOOST_MSVC)
@@ -153,9 +152,6 @@ struct equality_comparable1 : B
      friend bool operator!=(const T& x, const T& y) { return !(x == y); }
 };
 
-// A macro which produces "name_2left" from "name".
-#define BOOST_OPERATOR2_LEFT(name) name##2##_##left
-
 //  NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
 
 #if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
@@ -182,34 +178,33 @@ struct NAME##1 : B                                                            \
     { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 };
 
-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )           \
-template <class T, class U, class B = ::boost::detail::empty_base>  \
-struct NAME##2 : B                                                  \
-{                                                                   \
-  friend T operator OP( const T& lhs, const U& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
-};                                                                  \
-                                                                    \
-template <class T, class U, class B = ::boost::detail::empty_base>  \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                               \
-{                                                                   \
-  friend T operator OP( const U& lhs, const T& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
-};                                                                  \
-                                                                    \
-template <class T, class B = ::boost::detail::empty_base>           \
-struct NAME##1 : B                                                  \
-{                                                                   \
-  friend T operator OP( const T& lhs, const T& rhs )                \
-    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )                     \
+template <class T, class U, class B = ::boost::detail::empty_base>            \
+struct NAME##2 : B                                                            \
+{                                                                             \
+  friend T operator OP( const T& lhs, const U& rhs )                          \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
+};                                                                            \
+                                                                              \
+template <class T, class U, class B = ::boost::detail::empty_base>            \
+struct NAME##2_left : B                                                       \
+{                                                                             \
+  friend T operator OP( const U& lhs, const T& rhs )                          \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
+};                                                                            \
+                                                                              \
+template <class T, class B = ::boost::detail::empty_base>                     \
+struct NAME##1 : B                                                            \
+{                                                                             \
+  friend T operator OP( const T& lhs, const T& rhs )                          \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 };
 
 #else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 
-// For compilers without NRVO the following code is optimal, but not
-// symmetric!  Note that the implementation of
-// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
-// optimization opportunities to the compiler :)
+// For compilers without NRVO the following code is optimal, but not symmetric!
+// Note that the implementation of NAME##2_left only looks cool, but doesn't
+// provide optimization opportunities to the compiler :)
 
 #define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
 template <class T, class U, class B = ::boost::detail::empty_base>            \
@@ -225,24 +220,24 @@ struct NAME##1 : B                                                            \
   friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
 };
 
-#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
-template <class T, class U, class B = ::boost::detail::empty_base>      \
-struct NAME##2 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
-};                                                                      \
-                                                                        \
-template <class T, class U, class B = ::boost::detail::empty_base>      \
-struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
-{                                                                       \
-  friend T operator OP( const U& lhs, const T& rhs )                    \
-    { return T( lhs ) OP##= rhs; }                                      \
-};                                                                      \
-                                                                        \
-template <class T, class B = ::boost::detail::empty_base>               \
-struct NAME##1 : B                                                      \
-{                                                                       \
-  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )                     \
+template <class T, class U, class B = ::boost::detail::empty_base>            \
+struct NAME##2 : B                                                            \
+{                                                                             \
+  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
+};                                                                            \
+                                                                              \
+template <class T, class U, class B = ::boost::detail::empty_base>            \
+struct NAME##2_left : B                                                       \
+{                                                                             \
+  friend T operator OP( const U& lhs, const T& rhs )                          \
+    { return T( lhs ) OP##= rhs; }                                            \
+};                                                                            \
+                                                                              \
+template <class T, class B = ::boost::detail::empty_base>                     \
+struct NAME##1 : B                                                            \
+{                                                                             \
+  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
 };
 
 #endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
@@ -258,7 +253,6 @@ BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
 
 #undef BOOST_BINARY_OPERATOR_COMMUTATIVE
 #undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
-#undef BOOST_OPERATOR2_LEFT
 
 //  incrementable and decrementable contributed by Jeremy Siek
 

include/boost/ref.hpp

@@ -1,15 +1,13 @@
 #ifndef BOOST_REF_HPP_INCLUDED
-#define BOOST_REF_HPP_INCLUDED
+# define BOOST_REF_HPP_INCLUDED
 
-// MS compatible compilers support #pragma once
+# if _MSC_VER+0 >= 1020
+#  pragma once
+# endif
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/mpl/bool.hpp>
+# include <boost/config.hpp>
+# include <boost/utility/addressof.hpp>
+# include <boost/mpl/bool.hpp>
 
 //
 //  ref.hpp - ref/cref, useful helper functions
@@ -40,7 +38,7 @@ public:
 
 #else
 
-    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+    explicit reference_wrapper(T& t): t_(addressof(t)) {}
 
 #endif
 

include/boost/utility.hpp

@@ -1,10 +1,12 @@
 //  Boost utility.hpp header file  -------------------------------------------//
 
-//  Copyright 1999-2003 Boost.org.  Use, modification, and distribution are
-//  subject to the Boost Software License, Version 1.0.  (See accompanying file
-//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+//  (C) Copyright Boost.org 1999-2003. 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/utility/> for the library's home page.
+//  See http://www.boost.org/libs/utility for documentation.
 
 #ifndef BOOST_UTILITY_HPP
 #define BOOST_UTILITY_HPP
@@ -16,3 +18,4 @@
 #include <boost/noncopyable.hpp>
 
 #endif  // BOOST_UTILITY_HPP
+

include/boost/utility/base_from_member.hpp

@@ -1,10 +1,12 @@
 //  boost utility/base_from_member.hpp header file  --------------------------//
 
-//  Copyright 2001, 2003 Daryle Walker.  Use, modification, and distribution are
-//  subject to the Boost Software License, Version 1.0.  (See accompanying file
-//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+//  (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/libs/utility/> for the library's home page.
+//  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
@@ -30,7 +32,7 @@ class base_from_member
 protected:
     MemberType  member;
 
-    base_from_member()
+    explicit  base_from_member()
         : member()
         {}
 
@@ -49,48 +51,6 @@ protected:
         : member( x1, x2, x3 ) 
         {}
 
-    template< typename T1, typename T2, typename T3, typename T4 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4 )
-        : member( x1, x2, x3, x4 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5 )
-        : member( x1, x2, x3, x4, x5 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6 )
-        : member( x1, x2, x3, x4, x5, x6 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6, typename T7 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7 )
-        : member( x1, x2, x3, x4, x5, x6, x7 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6, typename T7, typename T8 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8 )
-        : member( x1, x2, x3, x4, x5, x6, x7, x8 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6, typename T7, typename T8, typename T9 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8,
-     T9 x9 )
-        : member( x1, x2, x3, x4, x5, x6, x7, x8, x9 ) 
-        {}
-
-    template< typename T1, typename T2, typename T3, typename T4, typename T5,
-     typename T6, typename T7, typename T8, typename T9, typename T10 >
-    base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7, T8 x8,
-     T9 x9, T10 x10 )
-        : member( x1, x2, x3, x4, x5, x6, x7, x8, x9, x10 ) 
-        {}
-
 };  // boost::base_from_member
 
 }  // namespace boost

include/boost/utility/compare_pointees.hpp

@@ -1,68 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/lib/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
-#define BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
-
-#include<functional>
-
-namespace boost {
-
-// template<class OP> bool equal_pointees(OP const& x, OP const& y);
-// template<class OP> struct equal_pointees_t;
-//
-// Being OP a model of OptionalPointee (either a pointer or an optional):
-//
-// If both x and y have valid pointees, returns the result of (*x == *y)
-// If only one has a valid pointee, returns false.
-// If none have valid pointees, returns true.
-// No-throw
-template<class OptionalPointee>
-inline
-bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
-{
-  return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
-}
-
-template<class OptionalPointee>
-struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
-{
-  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
-    { return equal_pointees(x,y) ; }
-} ;
-
-// template<class OP> bool less_pointees(OP const& x, OP const& y);
-// template<class OP> struct less_pointees_t;
-//
-// Being OP a model of OptionalPointee (either a pointer or an optional):
-//
-// If y has not a valid pointee, returns false.
-// ElseIf x has not a valid pointee, returns true.
-// ElseIf both x and y have valid pointees, returns the result of (*x < *y)
-// No-throw
-template<class OptionalPointee>
-inline
-bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
-{
-  return !y ? false : ( !x ? true : (*x) < (*y) ) ;
-}
-
-template<class OptionalPointee>
-struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
-{
-  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
-    { return less_pointees(x,y) ; }
-} ;
-
-} // namespace boost
-
-#endif
-

include/boost/utility/enable_if.hpp

@@ -1,119 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 <20> The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//    Authors: Jaakko J<>rvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-
-#ifndef BOOST_UTILITY_ENABLE_IF_HPP
-#define BOOST_UTILITY_ENABLE_IF_HPP
-
-#include "boost/config.hpp"
-
-// Even the definition of enable_if causes problems on some compilers,
-// so it's macroed out for all compilers that do not support SFINAE
-
-#ifndef BOOST_NO_SFINAE
-
-namespace boost
-{
- 
-  template <bool B, class T = void>
-  struct enable_if_c {
-    typedef T type;
-  };
-
-  template <class T>
-  struct enable_if_c<false, T> {};
-
-  template <class Cond, class T = void> 
-  struct enable_if : public enable_if_c<Cond::value, T> {};
-
-  template <bool B, class T>
-  struct lazy_enable_if_c {
-    typedef typename T::type type;
-  };
-
-  template <class T>
-  struct lazy_enable_if_c<false, T> {};
-
-  template <class Cond, class T> 
-  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
-
-
-  template <bool B, class T = void>
-  struct disable_if_c {
-    typedef T type;
-  };
-
-  template <class T>
-  struct disable_if_c<true, T> {};
-
-  template <class Cond, class T = void> 
-  struct disable_if : public disable_if_c<Cond::value, T> {};
-
-  template <bool B, class T>
-  struct lazy_disable_if_c {
-    typedef typename T::type type;
-  };
-
-  template <class T>
-  struct lazy_disable_if_c<true, T> {};
-
-  template <class Cond, class T> 
-  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
-
-} // namespace boost
-
-#else
-
-namespace boost {
-
-  namespace detail { typedef void enable_if_default_T; }
-
-  template <typename T>
-  struct enable_if_does_not_work_on_this_compiler;
-
-  template <bool B, class T = detail::enable_if_default_T>
-  struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <bool B, class T = detail::enable_if_default_T> 
-  struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <bool B, class T = detail::enable_if_default_T> 
-  struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <bool B, class T = detail::enable_if_default_T> 
-  struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <class Cond, class T = detail::enable_if_default_T> 
-  struct enable_if : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <class Cond, class T = detail::enable_if_default_T> 
-  struct disable_if : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <class Cond, class T = detail::enable_if_default_T> 
-  struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <class Cond, class T = detail::enable_if_default_T> 
-  struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-} // namespace boost
-
-#endif // BOOST_NO_SFINAE
-
-#endif

include/boost/utility_fwd.hpp

@@ -1,10 +1,12 @@
 //  Boost utility_fwd.hpp header file  ---------------------------------------//
 
-//  Copyright 2001, 2003 Boost.org.  Use, modification, and distribution are
-//  subject to the Boost Software License, Version 1.0.  (See accompanying file
-//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+//  (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/libs/utility/> for the library's home page.
+//  See http://www.boost.org/libs/utility for documentation.
 
 #ifndef BOOST_UTILITY_FWD_HPP
 #define BOOST_UTILITY_FWD_HPP
@@ -20,13 +22,12 @@ template < typename MemberType, int UniqueID = 0 >
     class base_from_member;
 
 
-//  From <boost/noncopyable.hpp>  --------------------------------------------//
+//  From <boost/utility.hpp>  ------------------------------------------------//
 
 class noncopyable;
 
 // Also has a few function templates
 
-
 }  // namespace boost
 
 

index.html

@@ -19,16 +19,16 @@
 				<a href="call_traits.htm">call_traits</a><br>
 				<a href="checked_delete.html">checked_delete</a><br>
 				<a href="compressed_pair.htm">compressed_pair</a><br>
-				<a href="enable_if.html">enable_if</a><br>
                 <a href="iterator_adaptors.htm">iterator_adaptors</a><br>
 				<a href="operators.htm">operators</a><br>
+				<a href="tie.html">tie</a><br>
 				<a href="throw_exception.html">throw_exception</a><br>
 				<a href="utility.htm">utility</a><br>
                 <a href="value_init.htm">value_init</a></p>
 		</blockquote>
 		<hr>
 		<p>Revised 
-			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->01 September, 2003<!--webbot bot="Timestamp" endspan i-checksum="38582" --></p>
+			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->09 January, 2003<!--webbot bot="Timestamp" endspan i-checksum="38582" --></p>
 		<p>&nbsp;</p>
 	</body>
-</html>
+</html>

indirect_iterator.htm

@@ -0,0 +1,444 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+
+<html>
+<head>
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+    <meta name="ProgId" content="FrontPage.Editor.Document">
+
+    <title>Indirect Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+	
+    <img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
+    "center" width="277" height="86"> 
+
+    <h1>Indirect Iterator Adaptor</h1>
+    Defined in header <a href=
+    "../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a> 
+
+    <p>The indirect iterator adaptor augments an iterator by applying an
+    <b>extra</b> dereference inside of <tt>operator*()</tt>. For example, this
+    iterator makes it possible to view a container of pointers or
+    smart-pointers (e.g. <tt>std::list&lt;boost::shared_ptr&lt;foo&gt;
+    &gt;</tt>) as if it were a container of the pointed-to type. The following
+    <b>pseudo-code</b> shows the basic idea of the indirect iterator:
+
+    <blockquote>
+<pre>
+// inside a hypothetical indirect_iterator class...
+typedef std::iterator_traits&lt;BaseIterator&gt;::value_type Pointer;
+typedef std::iterator_traits&lt;Pointer&gt;::reference reference;
+
+reference indirect_iterator::operator*() const {
+  return **this-&gt;base_iterator;
+}
+</pre>
+    </blockquote>
+
+    <h2>Synopsis</h2>
+
+    <blockquote>
+<pre>
+namespace boost {
+  template &lt;class BaseIterator,
+            class Value, class Reference, class Category, class Pointer&gt;
+  struct indirect_iterator_generator;
+  
+  template &lt;class BaseIterator,
+            class Value, class Reference, class ConstReference, 
+            class Category, class Pointer, class ConstPointer&gt;
+  struct indirect_iterator_pair_generator;
+
+  template &lt;class BaseIterator&gt;
+  typename indirect_iterator_generator&lt;BaseIterator&gt;::type
+  make_indirect_iterator(BaseIterator base)  
+}
+</pre>
+    </blockquote>
+    <hr>
+
+    <h2><a name="indirect_iterator_generator">The Indirect Iterator Type
+    Generator</a></h2>
+    The <tt>indirect_iterator_generator</tt> template is a <a href=
+    "../../more/generic_programming.html#type_generator">generator</a> of
+    indirect iterator types. The main template parameter for this class is the
+    <tt>BaseIterator</tt> type that is being wrapped. In most cases the type of
+    the elements being pointed to can be deduced using
+    <tt>std::iterator_traits</tt>, but in some situations the user may want to
+    override this type, so there are also template parameters that allow a user
+    to control the <tt>value_type</tt>, <tt>pointer</tt>, and
+    <tt>reference</tt> types of the resulting iterators. 
+
+    <blockquote>
+<pre>
+template &lt;class BaseIterator,
+          class Value, class Reference, class Pointer&gt;
+class indirect_iterator_generator
+{
+public:
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> type; // the resulting indirect iterator type 
+};
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    This example uses the <tt>indirect_iterator_generator</tt> to create
+    indirect iterators which dereference the pointers stored in the
+    <tt>pointers_to_chars</tt> array to access the <tt>char</tt>s in the
+    <tt>characters</tt> array. 
+
+    <blockquote>
+<pre>
+#include &lt;boost/config.hpp&gt;
+#include &lt;vector&gt;
+#include &lt;iostream&gt;
+#include &lt;iterator&gt;
+#include &lt;boost/iterator_adaptors.hpp&gt;
+
+int main(int, char*[])
+{
+  char characters[] = "abcdefg";
+  const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
+  char* pointers_to_chars[N];                        // at the end.
+  for (int i = 0; i &lt; N; ++i)
+    pointers_to_chars[i] = &amp;characters[i];
+  
+  boost::indirect_iterator_generator&lt;char**, char&gt;::type 
+    indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
+
+  std::copy(indirect_first, indirect_last, std::ostream_iterator&lt;char&gt;(std::cout, ","));
+  std::cout &lt;&lt; std::endl;
+  
+  // to be continued...
+</pre>
+    </blockquote>
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>BaseIterator</tt> 
+
+        <td>The iterator type being wrapped. The <tt>value_type</tt>
+        of the base iterator should itself be dereferenceable.  
+        The return type of the <tt>operator*</tt> for the
+        <tt>value_type</tt> should match the <tt>Reference</tt> type.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The <tt>value_type</tt> of the resulting iterator, unless const. If
+        Value is <tt>const X</tt>, a conforming compiler makes the
+        <tt>value_type</tt> <tt><i>non-</i>const X</tt><a href=
+        "iterator_adaptors.htm#1">[1]</a>. Note that if the default
+         is used for <tt>Value</tt>, then there must be a valid specialization
+         of <tt>iterator_traits</tt> for the value type of the base iterator.
+         <br>
+         <b>Default:</b> <tt>std::iterator_traits&lt;<br>
+         <20> std::iterator_traits&lt;BaseIterator&gt;::value_type
+        &gt;::value_type</tt><a href="#2">[2]</a> 
+
+      <tr>
+        <td><tt>Reference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator*()</tt>.<br>
+         <b>Default:</b> <tt>Value&amp;</tt> 
+
+      <tr>
+        <td><tt>Pointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> <tt>Value*</tt> 
+
+      <tr>
+        <td><tt>Category</tt> 
+        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BaseIterator&gt;::iterator_category</tt> 
+
+    </table>
+
+    <h3>Concept Model</h3>
+    The indirect iterator will model whichever <a href=
+    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator
+    concept category</a> is modeled by the base iterator. Thus, if the
+    base iterator is a model of <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+    Access Iterator</a> then so is the resulting indirect iterator. If
+    the base iterator models a more restrictive concept, the resulting
+    indirect iterator will model the same concept <a href="#3">[3]</a>.
+
+    <h3>Members</h3>
+    The indirect iterator type implements the member functions and operators
+    required of the <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> concept. In addition it has the following constructor: 
+<pre>
+explicit indirect_iterator_generator::type(const BaseIterator&amp; it)
+</pre>
+    <br>
+     <br>
+     
+    <hr>
+
+    <p>
+
+    <h2><a name="indirect_iterator_pair_generator">The Indirect Iterator Pair
+    Generator</a></h2>
+    Sometimes a pair of <tt>const</tt>/non-<tt>const</tt> pair of iterators is
+    needed, such as when implementing a container. The
+    <tt>indirect_iterator_pair_generator</tt> class makes it more convenient to
+    create this pair of iterator types. 
+
+    <blockquote>
+<pre>
+  template &lt;class BaseIterator,
+            class Value, class Reference, class ConstReference, 
+            class Category, class Pointer, class ConstPointer&gt;
+  struct indirect_iterator_pair_generator;
+{
+public:
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> iterator;       // the mutable indirect iterator type 
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> const_iterator; // the immutable indirect iterator type 
+};
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+
+    <blockquote>
+<pre>
+  // continuing from the last example...
+
+  typedef boost::indirect_iterator_pair_generator&lt;char**,
+    char, char*, char&amp;, const char*, const char&amp;&gt; PairGen;
+
+  char mutable_characters[N];
+  char* pointers_to_mutable_chars[N];
+  for (int i = 0; i &lt; N; ++i)
+    pointers_to_mutable_chars[i] = &amp;mutable_characters[i];
+
+  PairGen::iterator mutable_indirect_first(pointers_to_mutable_chars),
+    mutable_indirect_last(pointers_to_mutable_chars + N);
+  PairGen::const_iterator const_indirect_first(pointers_to_chars),
+    const_indirect_last(pointers_to_chars + N);
+
+  std::transform(const_indirect_first, const_indirect_last,
+     mutable_indirect_first, std::bind1st(std::plus&lt;char&gt;(), 1));
+
+  std::copy(mutable_indirect_first, mutable_indirect_last,
+      std::ostream_iterator&lt;char&gt;(std::cout, ","));
+  std::cout &lt;&lt; std::endl;
+  // to be continued...
+</pre>
+    </blockquote>
+
+    <p>The output is:
+
+    <blockquote>
+<pre>
+b,c,d,e,f,g,h,
+</pre>
+    </blockquote>
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt>BaseIterator</tt> 
+
+        <td>The iterator type being wrapped. The <tt>value_type</tt> of the
+        base iterator should itself be dereferenceable.
+        The return type of the <tt>operator*</tt> for the
+        <tt>value_type</tt> should match the <tt>Reference</tt> type.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The <tt>value_type</tt> of the resulting iterators.
+         If Value is <tt>const X</tt>, a conforming compiler makes the
+         <tt>value_type</tt> <tt><i>non-</i>const X</tt><a href=
+         "iterator_adaptors.htm#1">[1]</a>. Note that if the default
+         is used for <tt>Value</tt>, then there must be a valid
+         specialization of <tt>iterator_traits</tt> for the value type
+         of the base iterator.<br>
+
+         <b>Default:</b> <tt>std::iterator_traits&lt;<br>
+         <20> std::iterator_traits&lt;BaseIterator&gt;::value_type
+        &gt;::value_type</tt><a href="#2">[2]</a> 
+
+      <tr>
+        <td><tt>Reference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting <tt>iterator</tt>, and
+        in particular, the result type of its <tt>operator*()</tt>.<br>
+         <b>Default:</b> <tt>Value&amp;</tt> 
+
+      <tr>
+        <td><tt>ConstReference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting
+        <tt>const_iterator</tt>, and in particular, the result type of its
+        <tt>operator*()</tt>.<br>
+         <b>Default:</b> <tt>const Value&amp;</tt> 
+
+      <tr>
+        <td><tt>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> 
+
+        <td>The <tt>pointer</tt> type of the resulting <tt>const_iterator</tt>,
+        and in particular, the result type of its <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> <tt>const Value*</tt> 
+
+    </table>
+
+    <h3>Concept Model</h3>
+
+    The indirect iterators will model whichever <a href=
+    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator
+    concept category</a> is modeled by the base iterator. Thus, if the
+    base iterator is a model of <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+    Access Iterator</a> then so are the resulting indirect
+    iterators. If the base iterator models a more restrictive concept,
+    the resulting indirect iterators will model the same concept <a
+    href="#3">[3]</a>.
+
+
+    <h3>Members</h3>
+    The resulting <tt>iterator</tt> and <tt>const_iterator</tt> types implement
+    the member functions and operators required of the <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> concept. In addition they support the following constructors: 
+
+    <blockquote>
+<pre>
+explicit indirect_iterator_pair_generator::iterator(const BaseIterator&amp; it)
+explicit indirect_iterator_pair_generator::const_iterator(const BaseIterator&amp; it)
+</pre>
+    </blockquote>
+    <br>
+     <br>
+     
+    <hr>
+
+    <p>
+
+    <h2><a name="make_indirect_iterator">The Indirect Iterator Object
+    Generator</a></h2>
+    The <tt>make_indirect_iterator()</tt> function provides a more convenient
+    way to create indirect iterator objects. The function saves the user the
+    trouble of explicitly writing out the iterator types. 
+
+    <blockquote>
+<pre>
+template &lt;class BaseIterator&gt;
+typename indirect_iterator_generator&lt;BaseIterator&gt;::type
+make_indirect_iterator(BaseIterator base)  
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    Here we again print the <tt>char</tt>s from the array <tt>characters</tt>
+    by accessing them through the array of pointers <tt>pointer_to_chars</tt>,
+    but this time we use the <tt>make_indirect_iterator()</tt> function which
+    saves us some typing. 
+
+    <blockquote>
+<pre>
+  // continuing from the last example...
+
+  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
+      boost::make_indirect_iterator(pointers_to_chars + N),
+      std::ostream_iterator&lt;char&gt;(std::cout, ","));
+  std::cout &lt;&lt; std::endl;
+
+  return 0;
+}
+</pre>
+    </blockquote>
+    The output is: 
+
+    <blockquote>
+<pre>
+a,b,c,d,e,f,g,
+</pre>
+    </blockquote>
+    <hr>
+
+    <h3>Notes</h3>
+
+    <p>
+
+    <p><a name="2">[2]</a> If your compiler does not support partial
+    specialization and the base iterator or its <tt>value_type</tt> is a
+    builtin pointer type, you will not be able to use the default for
+    <tt>Value</tt> and will need to specify this type explicitly.
+
+    <p><a name="3">[3]</a>There is a caveat to which concept the
+    indirect iterator can model.  If the return type of the
+    <tt>operator*</tt> for the base iterator's value type is not a
+    true reference, then strickly speaking, the indirect iterator can
+    not be a model of <a href=
+    "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward
+    Iterator</a> or any of the concepts that refine it. In this case
+    the <tt>Category</tt> for the indirect iterator should be
+    specified as <tt>std::input_iterator_tag</tt>. However, even in
+    this case, if the base iterator is a random access iterator, the
+    resulting indirect iterator will still satisfy most of the
+    requirements for <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+    Access Iterator</a>.
+    
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->18 Sep 2001<!--webbot bot="Timestamp" endspan i-checksum="14941" -->
+
+
+    <p>&copy; Copyright Jeremy Siek and David Abrahams 2001. Permission to
+    copy, use, modify, sell and distribute this document is granted provided
+    this copyright notice appears in all copies. This document is provided "as
+    is" without express or implied warranty, and with no claim as to its
+    suitability for any purpose. 
+    <!--  LocalWords:  html charset alt gif hpp BaseIterator const namespace struct
+             -->
+     
+    <!--  LocalWords:  ConstPointer ConstReference typename iostream int abcdefg
+             -->
+     <!--  LocalWords:  sizeof  PairGen pre Jeremy Siek David Abrahams
+             -->
+
+
+</body>
+</html>

indirect_iterator_example.cpp

@@ -8,8 +8,7 @@
 #include <iostream>
 #include <iterator>
 #include <functional>
-#include <algorithm>
-#include <boost/iterator/indirect_iterator.hpp>
+#include <boost/iterator_adaptors.hpp>
 
 int main(int, char*[])
 {
@@ -21,7 +20,7 @@ int main(int, char*[])
 
   // Example of using indirect_iterator_generator
   
-  boost::indirect_iterator<char**, char>
+  boost::indirect_iterator_generator<char**, char>::type 
     indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
 
   std::copy(indirect_first, indirect_last, std::ostream_iterator<char>(std::cout, ","));
@@ -30,14 +29,16 @@ int main(int, char*[])
 
   // Example of using indirect_iterator_pair_generator
 
+  typedef boost::indirect_iterator_pair_generator<char**, char> PairGen;
+
   char mutable_characters[N];
   char* pointers_to_mutable_chars[N];
   for (int j = 0; j < N; ++j)
     pointers_to_mutable_chars[j] = &mutable_characters[j];
 
-  boost::indirect_iterator<char* const*> mutable_indirect_first(pointers_to_mutable_chars),
+  PairGen::iterator mutable_indirect_first(pointers_to_mutable_chars),
     mutable_indirect_last(pointers_to_mutable_chars + N);
-  boost::indirect_iterator<char* const*, char const> const_indirect_first(pointers_to_chars),
+  PairGen::const_iterator const_indirect_first(pointers_to_chars),
     const_indirect_last(pointers_to_chars + N);
 
   std::transform(const_indirect_first, const_indirect_last,
@@ -50,10 +51,12 @@ int main(int, char*[])
   
   // Example of using make_indirect_iterator()
 
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
   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;
 }

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) || BOOST_MSVC > 1200 || !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_STD_ITERATOR_TRAITS
+        , 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_STD_ITERATOR_TRAITS
+        , 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_STD_ITERATOR_TRAITS
+        , 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_STD_ITERATOR_TRAITS
+    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_STD_ITERATOR_TRAITS
+    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;
+}

iter_adaptor_fail_expected1.cpp

@@ -0,0 +1,27 @@
+//  Test boost/pending/iterator_adaptors.hpp
+
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+// Revision History
+// 21 Jan 01 Initial version (Jeremy Siek)
+
+#include <boost/config.hpp>
+#include <list>
+#include <boost/pending/iterator_adaptors.hpp>
+
+int main()
+{
+  typedef boost::iterator_adaptor<std::list<int>::iterator,
+    boost::default_iterator_policies,
+    int,int&,int*,std::bidirectional_iterator_tag> adaptor_type;
+  
+  adaptor_type i;
+  i += 4;
+  return 0;
+}

iter_adaptor_fail_expected2.cpp

@@ -0,0 +1,28 @@
+//  Test boost/pending/iterator_adaptors.hpp
+
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+// Revision History
+// 21 Jan 01 Initial version (Jeremy Siek)
+
+#include <boost/config.hpp>
+#include <iostream>
+#include <iterator>
+#include <boost/pending/iterator_adaptors.hpp>
+
+int main()
+{
+  typedef boost::iterator_adaptor<std::istream_iterator<int>,
+    boost::default_iterator_policies,
+    int,int&,int*,std::input_iterator_tag> adaptor_type;
+  
+  adaptor_type iter;
+  --iter;
+  return 0;
+}

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;
+}

iterator_adaptor_examples.cpp

@@ -7,7 +7,7 @@
 #include <functional>
 #include <algorithm>
 #include <iostream>
-#include <boost/iterator/transform_iterator.hpp>
+#include <boost/iterator_adaptors.hpp>
 #include <boost/pending/integer_range.hpp>
 
 int
@@ -21,8 +21,8 @@ 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*> doubling_iterator;
+  typedef boost::transform_iterator_generator<Function, int* 
+  >::type doubling_iterator;
 
   doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
     i_end(x + sizeof(x)/sizeof(int), std::bind1st(std::multiplies<int>(), 2));

iterator_adaptor_test.cpp

@@ -0,0 +1,454 @@
+//  Test boost/iterator_adaptors.hpp
+
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  30 Nov 01 Added permutation_iterator.(Toon Knapen)
+//  19 Nov 01 Added generator_iterator.  (Jens Maurer)
+//  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)
+//  11 Feb 01 Added test of operator-> for forward and input iterators.
+//            (Jeremy Siek)
+//  11 Feb 01 Borland fixes (David Abrahams)
+//  10 Feb 01 Use new adaptors interface. (David Abrahams)
+//  10 Feb 01 Use new filter_ interface. (David Abrahams)
+//  09 Feb 01 Use new reverse_ and indirect_ interfaces. Replace
+//            BOOST_NO_STD_ITERATOR_TRAITS with
+//            BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION to prove we've
+//            normalized to core compiler capabilities (David Abrahams)
+//  08 Feb 01 Use Jeremy's new make_reverse_iterator form; add more
+//            comprehensive testing. Force-decay array function arguments to
+//            pointers.
+//  07 Feb 01 Added tests for the make_xxx_iterator() helper functions.
+//            (Jeremy Siek)
+//  07 Feb 01 Replaced use of xxx_pair_generator with xxx_generator where
+//            possible (which was all but the projection iterator).
+//            (Jeremy Siek)
+//  06 Feb 01 Removed now-defaulted template arguments where possible
+//            Updated names to correspond to new generator naming convention.
+//            Added a trivial test for make_transform_iterator().
+//            Gave traits for const iterators a mutable value_type, per std.
+//            Resurrected my original tests for indirect iterators.
+//            (David Abrahams)
+//  04 Feb 01 Fix for compilers without standard iterator_traits
+//            (David Abrahams)
+//  13 Jun 00 Added const version of the iterator tests (Jeremy Siek)
+//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
+
+#include <boost/config.hpp>
+#include <iostream>
+
+#include <algorithm>
+#include <functional>
+#include <numeric>
+
+#include <boost/iterator_adaptors.hpp>
+#include <boost/generator_iterator.hpp>
+#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 <boost/permutation_iterator.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 mult_functor {
+  typedef int result_type;
+  typedef int argument_type;
+  // Functors used with transform_iterator must be
+  // DefaultConstructible, as the transform_iterator must be
+  // DefaultConstructible to satisfy the requirements for
+  // TrivialIterator.
+  mult_functor() { }
+  mult_functor(int aa) : a(aa) { }
+  int operator()(int b) const { return a * b; }
+  int a;
+};
+
+template <class Pair>
+struct select1st_ 
+  : public std::unary_function<Pair, typename Pair::first_type>
+{
+  const typename Pair::first_type& operator()(const Pair& x) const {
+    return x.first;
+  }
+  typename Pair::first_type& operator()(Pair& x) const {
+    return x.first;
+  }
+};
+
+struct one_or_four {
+  bool operator()(dummyT x) const {
+    return x.foo() == 1 || x.foo() == 4;
+  }
+};
+
+typedef std::deque<int> storage;
+typedef std::deque<int*> pointer_deque;
+typedef std::set<storage::iterator> iterator_set;
+
+template <class T> struct foo;
+
+void blah(int) { }
+
+struct my_gen
+{
+  typedef int result_type;
+  my_gen() : n(0) { }
+  int operator()() { return ++n; }
+  int n;
+};
+
+int
+main()
+{
+  dummyT array[] = { dummyT(0), dummyT(1), dummyT(2), 
+                     dummyT(3), dummyT(4), dummyT(5) };
+  const int N = sizeof(array)/sizeof(dummyT);
+
+  // sanity check, if this doesn't pass the test is buggy
+  boost::random_access_iterator_test(array, N, array);
+
+  // Check that the policy concept checks and the default policy
+  // implementation match up.
+  boost::function_requires< 
+     boost::RandomAccessIteratorPoliciesConcept<
+       boost::default_iterator_policies,
+       boost::iterator_adaptor<storage::iterator, boost::default_iterator_policies>,
+       boost::iterator<std::random_access_iterator_tag, int, std::ptrdiff_t,
+                      int*, int&>
+      > >();
+
+  // Test the named parameters
+  {
+    // 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 BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) || BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    // 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 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 the iterator_adaptor
+  {
+    boost::iterator_adaptor<dummyT*, boost::default_iterator_policies, dummyT> i(array);
+    boost::random_access_iterator_test(i, N, array);
+    
+    boost::iterator_adaptor<const dummyT*, boost::default_iterator_policies, const dummyT> j(array);
+    boost::random_access_iterator_test(j, N, array);
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+
+  // Test projection_iterator_pair_generator
+  {    
+    typedef std::pair<dummyT,dummyT> Pair;
+    Pair pair_array[N];
+    for (int k = 0; k < N; ++k)
+      pair_array[k].first = array[k];
+
+    typedef boost::projection_iterator_pair_generator<select1st_<Pair>,
+      Pair*, const Pair*
+      > Projection;
+    
+    Projection::iterator i(pair_array);
+    boost::random_access_iterator_test(i, N, array);
+
+    boost::random_access_iterator_test(boost::make_projection_iterator(pair_array, select1st_<Pair>()), N, array);    
+    boost::random_access_iterator_test(boost::make_projection_iterator< select1st_<Pair> >(pair_array), N, array);    
+
+    Projection::const_iterator j(pair_array);
+    boost::random_access_iterator_test(j, N, array);
+
+    boost::random_access_iterator_test(boost::make_const_projection_iterator(pair_array, select1st_<Pair>()), N, array);
+    boost::random_access_iterator_test(boost::make_const_projection_iterator<select1st_<Pair> >(pair_array), N, array);
+
+    boost::const_nonconst_iterator_test(i, ++j);
+  }
+
+  // Test reverse_iterator_generator
+  {
+    dummyT reversed[N];
+    std::copy(array, array + N, reversed);
+    std::reverse(reversed, reversed + N);
+    
+    typedef boost::reverse_iterator_generator<dummyT*
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_STD_ITERATOR_TRAITS)
+        , dummyT
+#endif
+      >::type reverse_iterator;
+    
+    reverse_iterator i(reversed + N);
+    boost::random_access_iterator_test(i, N, array);
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+#endif
+
+    typedef boost::reverse_iterator_generator<const dummyT*
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_STD_ITERATOR_TRAITS)
+      , dummyT, const dummyT&, const dummyT
+#endif
+      >::type const_reverse_iterator;
+    
+    const_reverse_iterator j(reversed + N);
+    boost::random_access_iterator_test(j, N, array);
+
+    const dummyT* const_reversed = reversed;
+    
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+#endif
+    
+    boost::const_nonconst_iterator_test(i, ++j);    
+  }
+
+  // Test reverse_iterator_generator again, with traits fully deducible on all platforms
+  {
+    std::deque<dummyT> reversed_container;
+    std::reverse_copy(array, array + N, std::back_inserter(reversed_container));
+    const std::deque<dummyT>::iterator reversed = reversed_container.begin();
+
+
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::iterator>::type reverse_iterator;
+    typedef boost::reverse_iterator_generator<
+        std::deque<dummyT>::const_iterator, const dummyT>::type const_reverse_iterator;
+
+    // MSVC/STLport gives an INTERNAL COMPILER ERROR when any computation
+    // (e.g. "reversed + N") is used in the constructor below.
+    const std::deque<dummyT>::iterator finish = reversed_container.end();
+    reverse_iterator i(finish);
+    
+    boost::random_access_iterator_test(i, N, array);
+    boost::random_access_iterator_test(boost::make_reverse_iterator(reversed + N), N, array);
+
+    const_reverse_iterator j = reverse_iterator(finish);
+    boost::random_access_iterator_test(j, N, array);
+
+    const std::deque<dummyT>::const_iterator const_reversed = reversed;
+    boost::random_access_iterator_test(boost::make_reverse_iterator(const_reversed + N), N, array);
+    
+    // Many compilers' builtin deque iterators don't interoperate well, though
+    // STLport fixes that problem.
+#if defined(__SGI_STL_PORT)                                            \
+ || (!BOOST_WORKAROUND(__GNUC__, < 3)                                   \
+     && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))         \
+     && !BOOST_WORKAROUND(BOOST_MSVC, <= 1200))
+    
+    boost::const_nonconst_iterator_test(i, ++j);
+#endif
+  }
+  
+  // Test integer_range's iterators
+  {
+    int int_array[] = { 0, 1, 2, 3, 4, 5 };
+    boost::integer_range<int> r(0, 5);
+    boost::random_access_iterator_test(r.begin(), r.size(), int_array);
+  }
+
+  // Test filter iterator
+  {
+    // Using typedefs for filter_gen::type confused Borland terribly.
+    typedef boost::detail::non_bidirectional_category<dummyT*>::type category;
+    
+    typedef boost::filter_iterator_generator<one_or_four, dummyT*
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || defined(BOOST_NO_STD_ITERATOR_TRAITS)
+        , dummyT
+#endif
+        >::type filter_iter;
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    // 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 !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    enum { is_forward = boost::is_same<
+           filter_iter::iterator_category,
+           std::forward_iterator_tag>::value };
+    BOOST_STATIC_ASSERT(is_forward);
+#endif
+
+    // On compilers not supporting partial specialization, we can do more type
+    // deduction with deque iterators than with pointers... unless the library
+    // is broken ;-(
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && !__SGI_STL_PORT)
+    std::deque<dummyT> array2;
+    std::copy(array+0, array+N, std::back_inserter(array2));
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array2.begin(), array2.end(), one_or_four()),
+        dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array2.begin(), array2.end()),
+        dummyT(1), dummyT(4));
+#endif
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1200) // This just freaks MSVC6 out completely
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(
+            boost::make_reverse_iterator(array2.end()),
+            boost::make_reverse_iterator(array2.begin())
+            ),
+        dummyT(4), dummyT(1));
+#endif
+    
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
+    boost::forward_iterator_test(
+        boost::make_filter_iterator(array+0, array+N, one_or_four()),
+        dummyT(1), dummyT(4));
+
+    boost::forward_iterator_test(
+        boost::make_filter_iterator<one_or_four>(array, array + N),
+        dummyT(1), dummyT(4));
+
+#endif
+  }
+
+  // check operator-> with a forward iterator
+  {
+    boost::forward_iterator_archetype<dummyT> forward_iter;
+    
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    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);
+    int zero = 0;
+    if (zero) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+  // check operator-> with an input iterator
+  {
+    boost::input_iterator_archetype<dummyT> input_iter;
+    typedef boost::iterator_adaptor<boost::input_iterator_archetype<dummyT>,
+      boost::default_iterator_policies,
+      dummyT, const dummyT&, const dummyT*, 
+      std::input_iterator_tag, std::ptrdiff_t> adaptor_type;
+    adaptor_type i(input_iter);
+    int zero = 0;
+    if (zero) // don't do this, just make sure it compiles
+      assert((*i).m_x == i->foo());      
+  }
+
+  {
+    // check generator_iterator
+    my_gen g1;
+    boost::generator_iterator_generator<my_gen>::type gen =
+      boost::make_generator_iterator(g1);
+    assert(*gen == 1);
+    ++gen;
+    gen++;
+    assert(*gen == 3);
+  }
+
+  {
+    // check permutation_iterator
+    typedef std::deque< int > element_range_type;
+    typedef std::list< int > index_type;
+    
+    static const int element_range_size = 10;
+    static const int index_size = 4;
+    
+    element_range_type elements( element_range_size );
+    
+    for(element_range_type::iterator el_it = elements.begin();
+        el_it != elements.end();
+        ++el_it)
+    {
+        *el_it = std::distance( elements.begin(), el_it );
+    }
+    
+    index_type indices( index_size );
+    
+    for(index_type::iterator i_it = indices.begin();
+        i_it != indices.end();
+        ++i_it)
+    {
+        *i_it = element_range_size - index_size
+            + std::distance(indices.begin(), i_it );
+    }
+    
+    std::reverse( indices.begin(), indices.end() );
+    
+    typedef boost::permutation_iterator_generator< element_range_type::iterator, index_type::iterator >::type permutation_type;
+    permutation_type begin = boost::make_permutation_iterator( elements.begin(), indices.begin() );
+    permutation_type end = boost::make_permutation_iterator( elements.begin(), indices.end() );
+
+    int expected_outcome[] = { 9, 8, 7, 6 };
+    assert( std::equal( begin, end, expected_outcome ) );
+  }
+
+  std::cout << "test successful " << std::endl;
+  return 0;
+}

iterator_traits_test.cpp

@@ -147,7 +147,9 @@ template <class Iterator,
     class value_type, class difference_type, class pointer, class reference, class category>
 struct maybe_pointer_test
     : portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
       , non_portable_tests<Iterator,value_type,difference_type,pointer,reference,category>
+#endif
 {
 };
 

numeric_traits_test.cpp

@@ -214,7 +214,7 @@ struct signed_tag {};
 // Tests for unsigned numbers. The extra default Number parameter works around
 // an MSVC bug.
 template <class Number>
-void test_aux(unsigned_tag, Number*)
+void test_aux(unsigned_tag, Number* = 0)
 {
     typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
     BOOST_STATIC_ASSERT(!boost::detail::is_signed<Number>::value);
@@ -256,7 +256,7 @@ struct in_range_tag {};
 // This test morsel gets executed for numbers whose difference will always be
 // representable in intmax_t
 template <class Number>
-void signed_test(in_range_tag, Number*)
+void signed_test(in_range_tag, Number* = 0)
 {
     BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
     typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
@@ -277,7 +277,7 @@ void signed_test(in_range_tag, Number*)
 // This test morsel gets executed for numbers whose difference may exceed the
 // capacity of intmax_t.
 template <class Number>
-void signed_test(out_of_range_tag, Number*)
+void signed_test(out_of_range_tag, Number* = 0)
 {
     BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
     typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
@@ -301,7 +301,7 @@ void signed_test(out_of_range_tag, Number*)
 }
 
 template <class Number>
-void test_aux(signed_tag, Number*)
+void test_aux(signed_tag, Number* = 0)
 {
     typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
     BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
@@ -328,7 +328,7 @@ void test_aux(signed_tag, Number*)
                           out_of_range_tag
                         >::type
         range_tag;
-    signed_test<Number>(range_tag(), 0);
+    signed_test<Number>(range_tag());
 }
 
 
@@ -358,7 +358,7 @@ void test(Number* = 0)
         boost::detail::is_signed<Number>::value
         >::template then<signed_tag, unsigned_tag>::type signedness;
     
-    test_aux<Number>(signedness(), 0);
+    test_aux<Number>(signedness());
     std::cout << "passed" << std::endl;
 }
 

operators.htm

@@ -344,15 +344,6 @@ class MyInt
       above</li>
     </ul>
 
-    <p>As Daniel Kr&uuml;gler pointed out, this technique violates 14.6.5/2
-    and is thus non-portable. The reasoning is, that the operators injected 
-    by the instantiation of e.g.
-    <code>less_than_comparable&lt;myclass&gt;</code> can not be found
-    by ADL according to the rules given by 3.4.2/2, since myclass is
-    not an associated class of
-    <code>less_than_comparable&lt;myclass&gt;</code>.
-    Thus only use this technique if all else fails.</p>
-
     <h3>Requirement <a name="portability">Portability</a></h3>
 
     <p>Many compilers (<i>e.g.</i> MSVC 6.3, GCC 2.95.2) will not enforce the
@@ -983,6 +974,7 @@ T operator+( T lhs, const T&amp; rhs )
     that don't implement the NRVO. <br>
      <br>
      
+
     <h3><a name="grpd_oprs">Grouped Arithmetic Operators</a></h3>
 
     <p>The following templates provide common groups of related operations.
@@ -2070,7 +2062,6 @@ public:
 
       <dd>Contributed the NRVO-friendly and symmetric implementation of
       arithmetic operators.</dd>
-
     </dl>
 
     <h2>Note for Users of <a name="old_lib_note">Older Versions</a></h2>
@@ -2119,15 +2110,13 @@ public:
     backward-compatible.</p>
     <hr>
 
-    <p>Revised: 03 Dec 2003</p>
+    <p>Revised: 30 Oct 2001</p>
 
-    <p>Copyright &copy; Beman Dawes, David Abrahams, 1999-2001.</p>
-    <p>Copyright &copy; Daniel Frey, 2002-2003.</p>
-    <p>Use, modification, and distribution is subject to the Boost Software 
-    License, Version 1.0. (See accompanying file
-    <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy at
-    <a href="http://www.boost.org/LICENSE_1_0.txt">
-    www.boost.org/LICENSE_1_0.txt</a>)</p>
+    <p>Copyright &copy; David Abrahams and Beman Dawes 1999-2001. Permission
+    to copy, use, modify, sell and distribute this document is granted
+    provided this copyright notice appears in all copies. This document is
+    provided "as is" without express or implied warranty, and with no claim
+    as to its suitability for any purpose.</p>
   </body>
 </html>
 

operators_test.cpp

@@ -1,9 +1,11 @@
 //  Demonstrate and test boost/operators.hpp  -------------------------------//
 
-//  Copyright Beman Dawes 1999.
-//  See accompanying license for terms and conditions of use.
+//  (C) Copyright Beman Dawes 1999. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
 
-//  See http://www.boost.org/libs/utility for documentation.
+//  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
 //  01 Oct 01 Added tests for "left" operators
@@ -317,20 +319,11 @@ namespace
         test_multipliable_aux( x1, y1, x2, y2 );
         test_multipliable_aux( y1, x1, y2, x2 );
     }
-
-  template <class A, class B>
-  void test_value_equality(A a, B b)
-  {
-      BOOST_TEST(a.value() == b);
-  }
-  
-#define TEST_OP_R(op) test_value_equality(x1 op y1, x2 op y2)
-#define TEST_OP_L(op) test_value_equality(y1 op x1, y2 op x2)
-  
+    
     template <class X1, class Y1, class X2, class Y2>
     void test_addable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        TEST_OP_R(+);
+        BOOST_TEST( (x1 + y1).value() == (x2 + y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -340,19 +333,19 @@ namespace
         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 );
-        TEST_OP_R(-);
+        BOOST_TEST( (x1 - y1).value() == (x2 - y2) );
     }
 
     template <class X1, class Y1, class X2, class Y2>
     void test_subtractable_left(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
         sanity_check( x1, y1, x2, y2 );
-        TEST_OP_L(-);
+        BOOST_TEST( (y1 - x1).value() == (y2 - x2) );
     }
 
     template <class X1, class Y1, class X2, class Y2>
@@ -360,7 +353,7 @@ namespace
     {
         sanity_check( x1, y1, x2, y2 );
         if ( y2 != 0 )
-            TEST_OP_R(/);
+            BOOST_TEST( (x1 / y1).value() == (x2 / y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -368,7 +361,7 @@ namespace
     {
         sanity_check( x1, y1, x2, y2 );
         if ( x2 != 0 )
-            TEST_OP_L(/);
+            BOOST_TEST( (y1 / x1).value() == (y2 / x2) );
     }
 
     template <class X1, class Y1, class X2, class Y2>
@@ -376,7 +369,7 @@ namespace
     {
         sanity_check( x1, y1, x2, y2 );
         if ( y2 != 0 )
-            TEST_OP_R(%);
+            BOOST_TEST( (x1 % y1).value() == (x2 % y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -384,13 +377,13 @@ namespace
     {
         sanity_check( x1, y1, x2, y2 );
         if ( x2 != 0 )
-            TEST_OP_L(%);
+            BOOST_TEST( (y1 % x1).value() == (y2 % x2) );
     }
 
     template <class X1, class Y1, class X2, class Y2>
     void test_xorable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        TEST_OP_R(^);
+        BOOST_TEST( (x1 ^ y1).value() == (x2 ^ y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -404,7 +397,7 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void test_andable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        TEST_OP_R(&);
+        BOOST_TEST( (x1 & y1).value() == (x2 & y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -418,7 +411,7 @@ namespace
     template <class X1, class Y1, class X2, class Y2>
     void test_orable_aux(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
-        TEST_OP_R(|);
+        BOOST_TEST( (x1 | y1).value() == (x2 | y2) );
     }
     
     template <class X1, class Y1, class X2, class Y2>
@@ -433,14 +426,14 @@ namespace
     void test_left_shiftable(X1 x1, Y1 y1, X2 x2, Y2 y2)
     {
         sanity_check( x1, y1, x2, y2 );
-        TEST_OP_R(<<);
+        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 );
-        TEST_OP_R(>>);
+        BOOST_TEST( (x1 >> y1).value() == (x2 >> y2) );
     }
     
     template <class X1, class X2>
@@ -562,6 +555,7 @@ template Wrapped6<unsigned int, unsigned char>;
 
 #define PRIVATE_EXPR_TEST(e, t)  BOOST_TEST( ((e), (t)) )
 
+
 int
 test_main( int , char * [] )
 {
@@ -637,7 +631,7 @@ test_main( int , char * [] )
 
     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);

permutation_iterator.htm

@@ -0,0 +1,177 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+
+<html>
+<head>
+<title>Permutation Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+        
+<h1>Permutation Iterator Adaptor</h1>
+<p>Defined in header <a href="../../boost/permutation_iterator.hpp">boost/permutation_iterator.hpp</a></p>
+<p>The permutation iterator adaptor provides an iterator to a permutation of a given range.
+(<a href="http://www.cut-the-knot.com/do_you_know/permutation.html">see definition of permutation</a>).
+The adaptor takes two arguments
+<ul>
+<li>an iterator to the range V on which the <a href="http://www.cut-the-knot.com/do_you_know/permutation.html">permutation</a> will be applied</li>
+<li>the reindexing scheme that defines how the elements of V will be permuted.</li>
+</ul>
+
+<p>Note that the permutation iterator is not limited to strict permutations of the given range V. 
+The distance between begin and end of the reindexing iterators is allowed to be smaller compared to the 
+size of the range V, in which case the permutation iterator only provides a permutation of a subrange of V. 
+The indexes neither need to be unique. In this same context, it must be noted that the past the end permutation iterator is 
+completely defined by means of the past-the-end iterator to the indices</p> 
+
+<h2>Synopsis</h2>
+
+<blockquote>
+<pre>
+namespace boost {
+  template &lt;class IndexIterator&gt;
+  class permutation_iterator_policies;
+
+  template &lt;class ElementIterator, class IndexIterator&gt;
+  class permutation_iterator_generator;
+
+  template &lt;class ElementIterator, class IndexIterator&gt;
+  typename permutation_iterator_generator&lt;ElementIterator, IndexIterator&gt;::type
+  make_permutation_iterator(ElementIterator&amp; base, IndexIterator&amp; indexing);
+}
+</pre>
+</blockquote>
+
+
+<h2>The Permutation Iterator Generator Class Template</h2>
+
+<p>The <code>permutation_iterator_generator</code> is a helper class whose purpose
+is to construct a permutation iterator <strong>type</strong>. This class has
+two template arguments, the first being the iterator type over the range V, the
+second being the type of the iterator over the indices.
+
+<blockquote>
+<pre>
+template &lt;class ElementIterator, class IndexIterator&gt;
+class permutation_iterator_generator
+{
+public:
+  typedef <a href="iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt; type; // the resulting permutation iterator type 
+}
+</pre>
+</blockquote>
+
+
+<h3>Template Parameters</h3>
+
+<table border>
+<tr>
+<th>Parameter</th>
+<th>Description</th>
+</tr>
+
+<tr>
+<td><tt>ElementIterator</tt></td>
+<td>The iterator over the elements to be permuted. This type must be a model
+of <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a></td>
+</td>
+
+<tr>
+<td><tt>IndexIterator</tt></td>
+<td>The iterator over the new indexing scheme. This type must at least be a model
+of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>.
+The <code>IndexIterator::value_type</code> must be convertible to the 
+<code>ElementIterator::difference_type</code>.</td>
+</table>
+
+<h3>Concept Model</h3>
+The permutation iterator is always a model of the same concept as the IndexIterator.
+
+<h3>Members</h3>
+The permutation iterator implements the member functions
+and operators required for the 
+<a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
+concept. However, the permutation iterator can only meet the complexity guarantees 
+of the same concept as the IndexIterator. Thus for instance, although the permutation
+iterator provides <code>operator+=(distance)</code>, this operation will take linear time
+in case the IndexIterator is a model of ForwardIterator instead of amortized constant time.
+
+<br>
+
+<h2><a name="make_generator_iterator">The Permutation Iterator Object Generator</a></h2>
+
+The <code>make_permutation_iterator()</code> function provides a
+convenient way to create permutation iterator objects. The function
+saves the user the trouble of explicitly writing out the iterator
+types.
+
+<blockquote>
+<pre>
+template &lt;class ElementIterator, class IndexIterator &gt;
+typename permutation_iterator_generator&lt;ElementIterator, IndexIterator&gt;::type
+make_permutation_iterator(ElementIterator&amp; base, IndexIterator&amp; indices);
+</pre>
+</blockquote>
+
+<h2>Example</h2>
+<blockquote>
+<pre>
+  using namespace boost;
+  int i = 0;
+
+  typedef std::vector< int > element_range_type;
+  typedef std::list< int > index_type;
+
+  static const int element_range_size = 10;
+  static const int index_size = 4;
+
+  element_range_type elements( element_range_size );
+  for(element_range_type::iterator el_it = elements.begin() ; el_it != elements.end() ; ++el_it) *el_it = std::distance(elements.begin(), el_it);
+
+  index_type indices( index_size );
+  for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it ) *i_it = element_range_size - index_size + std::distance(indices.begin(), i_it);
+  std::reverse( indices.begin(), indices.end() );
+
+  typedef permutation_iterator_generator< element_range_type::iterator, index_type::iterator >::type permutation_type;
+  permutation_type begin = make_permutation_iterator( elements.begin(), indices.begin() );
+  permutation_type it = begin;
+  permutation_type end = make_permutation_iterator( elements.begin(), indices.end() );
+
+  std::cout << "The original range is : ";
+  std::copy( elements.begin(), elements.end(), std::ostream_iterator< int >( std::cout, " " ) );
+  std::cout << "\n";
+
+  std::cout << "The reindexing scheme is : ";
+  std::copy( indices.begin(), indices.end(), std::ostream_iterator< int >( std::cout, " " ) );
+  std::cout << "\n";
+
+  std::cout << "The permutated range is : ";
+  std::copy( begin, end, std::ostream_iterator< int >( std::cout, " " ) );
+  std::cout << "\n";
+
+  std::cout << "Elements at even indices in the permutation : ";
+  it = begin;
+  for(i = 0; i < index_size / 2 ; ++i, it+=2 ) std::cout << *it << " ";
+  std::cout << "\n";
+
+  std::cout << "Permutation backwards : ";
+  it = begin + (index_size);
+  assert( it != begin );
+  for( ; it-- != begin ; ) std::cout << *it << " ";
+  std::cout << "\n";
+
+  std::cout << "Iterate backward with stride 2 : ";
+  it = begin + (index_size - 1);
+  for(i = 0 ; i < index_size / 2 ; ++i, it-=2 ) std::cout << *it << " ";
+  std::cout << "\n";
+</pre>
+</blockquote>
+
+<br><br><br><hr>
+Thanks: The permutation iterator is only a small addition to the superb iterator adaptors
+library of David Abrahams and Jeremy Siek.
+<br><br>
+
+Copyright 2001 Toon Knapen.
+
+</body>
+</html>

projection_iterator.htm

@@ -0,0 +1,391 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<title>Projection Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+align="center" width="277" height="86">
+
+<h1>Projection Iterator Adaptor</h1>
+
+Defined in header
+<a href="../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
+
+<p>
+The projection iterator adaptor is similar to the <a
+href="./transform_iterator.htm">transform iterator adaptor</a> in that
+its <tt>operator*()</tt> applies some function to the result of
+dereferencing the base iterator and then returns the result. The
+difference is that the function must return a reference to some
+existing object (for example, a data member within the
+<tt>value_type</tt> of the base iterator). The following
+<b>pseudo-code</b> gives the basic idea. The data member <tt>p</tt> is
+the function object.
+
+<pre>
+  reference projection_iterator::operator*() const {
+    return this->p(*this->base_iterator);
+  }
+</pre>
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+  struct projection_iterator_generator;
+  
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, 
+            class BaseIterator, class ConstBaseIterator&gt;
+  struct projection_iterator_pair_generator;
+
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+  typename projection_iterator_generator&lt;AdaptableUnaryFunction, BaseIterator&gt;::type
+  make_projection_iterator(BaseIterator base,
+			   const AdaptableUnaryFunction& p = AdaptableUnaryFunction())
+
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class ConstBaseIterator&gt;
+  typename projection_iterator_generator&lt;AdaptableUnaryFunction, ConstBaseIterator&gt;::type
+  make_const_projection_iterator(ConstBaseIterator base,
+                                 const AdaptableUnaryFunction& p = AdaptableUnaryFunction())  
+}
+</pre>
+
+<hr>
+
+<h2><a name="projection_iterator_generator">The Projection Iterator Type
+Generator</a></h2>
+
+The class <tt>projection_iterator_generator</tt> is a helper class
+whose purpose is to construct an projection iterator type.  The main
+template parameter for this class is the <a
+href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html"><tt>AdaptableUnaryFunction</tt></a>
+function object type and the <tt>BaseIterator</tt> type that is being
+wrapped.
+
+<pre>
+template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+class projection_iterator_generator
+{
+public:
+  typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt;</tt> type; // the resulting projection iterator type 
+};
+</pre>
+
+<h3>Example</h3>
+
+In the following example we have a list of personnel records. Each
+record has an employee's name and ID number. We want to be able to
+traverse through the list accessing either the name or the ID numbers
+of the employees using the projection iterator so we create the
+function object classes <tt>select_name</tt> and
+<tt>select_ID</tt>. We then use the
+<tt>projection_iterator_generator</tt> class to create a projection
+iterator and use it to print out the names of the employees.
+
+<pre>
+#include &lt;boost/config.hpp&gt;
+#include &lt;list&gt;
+#include &lt;iostream&gt;
+#include &lt;iterator&gt;
+#include &lt;algorithm&gt;
+#include &lt;string&gt;
+#include &lt;boost/iterator_adaptors.hpp&gt;
+
+struct personnel_record {
+  personnel_record(std::string n, int id) : m_name(n), m_ID(id) { }
+  std::string m_name;
+  int m_ID;
+};
+
+struct select_name {
+  typedef personnel_record argument_type;
+  typedef std::string result_type;
+  const std::string&amp; operator()(const personnel_record&amp; r) const {
+    return r.m_name;
+  }
+  std::string&amp; operator()(personnel_record&amp; r) const {
+    return r.m_name;
+  }
+};
+
+struct select_ID {
+  typedef personnel_record argument_type;
+  typedef int result_type;
+  const int&amp; operator()(const personnel_record&amp; r) const {
+    return r.m_ID;
+  }
+  int&amp; operator()(personnel_record&amp; r) const {
+    return r.m_ID;
+  }
+};
+
+int main(int, char*[])
+{
+  std::list&lt;personnel_record&gt; personnel_list;
+
+  personnel_list.push_back(personnel_record("Barney", 13423));
+  personnel_list.push_back(personnel_record("Fred", 12343));
+  personnel_list.push_back(personnel_record("Wilma", 62454));
+  personnel_list.push_back(personnel_record("Betty", 20490));
+
+  // Example of using projection_iterator_generator
+  // to print out the names in the personnel list.
+
+  boost::projection_iterator_generator&lt;select_name,
+    std::list&lt;personnel_record&gt;::iterator&gt;::type
+    personnel_first(personnel_list.begin()),
+    personnel_last(personnel_list.end());
+
+  std::copy(personnel_first, personnel_last,
+            std::ostream_iterator&lt;std::string&gt;(std::cout, "\n"));
+  std::cout &lt;&lt; std::endl;
+
+  // to be continued...
+</pre>
+The output for this part is:
+<pre>
+Barney
+Fred
+Wilma
+Betty
+</pre>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html"><tt>AdaptableUnaryFunction</tt></a></TD>
+<TD>The type of the function object. The <tt>argument_type</tt> of the
+function must match the value type of the base iterator. The function
+should return a reference to the function's <tt>result_type</tt>.
+The <tt>result_type</tt> will be the resulting iterator's <tt>value_type</tt>.
+</TD>
+</TD>
+
+<TR>
+<TD><tt>BaseIterator</tt></TD>
+<TD>The iterator type being wrapped.</TD>
+</TD>
+</TR>
+
+</Table>
+
+<h3>Model of</h3>
+
+If the base iterator is a model of <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> then so is the resulting projection iterator.  If
+the base iterator supports less functionality than this the resulting
+projection iterator will also support less functionality.
+
+<h3>Members</h3>
+
+The projection iterator type implements the member functions and
+operators required of the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> concept.
+In addition it has the following constructor:
+
+<pre>
+projection_iterator_generator::type(const BaseIterator&amp; it,
+                                    const AdaptableUnaryFunction&amp; p = AdaptableUnaryFunction())
+</pre>
+
+<p>
+<hr>
+<p>
+
+<h2><a name="projection_iterator_pair_generator">The Projection Iterator Pair
+Generator</a></h2>
+
+Sometimes a mutable/const pair of iterator types is needed, such as
+when implementing a container type. The
+<tt>projection_iterator_pair_generator</tt> class makes it more
+convenient to create this pair of iterator types.
+
+<pre>
+template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator, class ConstBaseIterator&gt;
+class projection_iterator_pair_generator
+{
+public:
+  typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt;</tt> iterator;       // the mutable projection iterator type 
+  typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt;</tt> const_iterator; // the immutable projection iterator type 
+};
+</pre>
+
+<h3>Example</h3>
+
+In this part of the example we use the
+<tt>projection_iterator_pair_generator</tt> to create a mutable/const
+pair of projection iterators that access the ID numbers of the
+personnel. We use the mutable iterator to re-index the ID numbers from
+zero. We then use the constant iterator to print the ID numbers out.
+
+<pre>
+  // continuing from the last example...
+
+  typedef boost::projection_iterator_pair_generator&lt;select_ID,
+    std::list&lt;personnel_record&gt;::iterator,
+    std::list&lt;personnel_record&gt;::const_iterator&gt; PairGen;
+
+  PairGen::iterator ID_first(personnel_list.begin()),
+    ID_last(personnel_list.end());
+
+  int new_id = 0;
+  while (ID_first != ID_last) {
+    *ID_first = new_id++;
+    ++ID_first;
+  }
+
+  PairGen::const_iterator const_ID_first(personnel_list.begin()),
+    const_ID_last(personnel_list.end());
+
+  std::copy(const_ID_first, const_ID_last,
+            std::ostream_iterator&lt;int&gt;(std::cout, " "));
+  std::cout &lt;&lt; std::endl;
+  std::cout &lt;&lt; std::endl;
+  
+  // to be continued...
+</pre&gt;
+The output is:
+<pre>
+0 1 2 3 
+</pre>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html"><tt>AdaptableUnaryFunction</tt></a></TD>
+<TD>The type of the function object. The <tt>argument_type</tt> of the
+function must match the value type of the base iterator. The function
+should return a true reference to the function's <tt>result_type</tt>.
+The <tt>result_type</tt> will be the resulting iterator's <tt>value_type</tt>.
+</TD>
+</TD>
+
+<TR>
+<TD><tt>BaseIterator</tt></TD>
+<TD>The mutable iterator type being wrapped.</TD>
+</TD>
+</TR>
+
+<TR>
+<TD><tt>ConstBaseIterator</tt></TD>
+<TD>The constant iterator type being wrapped.</TD>
+</TD>
+</TR>
+
+</Table>
+
+<h3>Model of</h3>
+
+If the base iterator types model the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> then so do the resulting projection iterator
+types.  If the base iterators support less functionality the
+resulting projection iterator types will also support less
+functionality.  The resulting <tt>iterator</tt> type is mutable, and
+the resulting <tt>const_iterator</tt> type is constant.
+
+<h3>Members</h3>
+
+The resulting <tt>iterator</tt> and <tt>const_iterator</tt> types
+implements the member functions and operators required of the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random
+Access Iterator</a> concept.  In addition they support the following
+constructors:
+
+<pre>
+projection_iterator_pair_generator::iterator(const BaseIterator&amp; it,
+                                             const AdaptableUnaryFunction&amp; p = AdaptableUnaryFunction())</pre>
+
+<pre>
+projection_iterator_pair_generator::const_iterator(const BaseIterator&amp; it,
+                                                   const AdaptableUnaryFunction&amp; p = AdaptableUnaryFunction())
+</pre>
+
+<p>
+<hr>
+<p>
+
+<h2><a name="make_projection_iterator">The Projection Iterator Object Generators</a></h2>
+
+The <tt>make_projection_iterator()</tt> and
+<tt>make_const_projection_iterator()</tt> functions provide a more
+convenient way to create projection iterator objects. The functions
+save the user the trouble of explicitly writing out the iterator
+types.
+
+<pre>
+template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+typename projection_iterator_generator&lt;AdaptableUnaryFunction, BaseIterator&gt;::type
+make_projection_iterator(BaseIterator base,
+			 const AdaptableUnaryFunction& p = AdaptableUnaryFunction())  
+
+template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class ConstBaseIterator&gt;
+typename projection_iterator_generator&lt;AdaptableUnaryFunction, ConstBaseIterator&gt;::type
+make_const_projection_iterator(ConstBaseIterator base,
+			       const AdaptableUnaryFunction& p = AdaptableUnaryFunction())  
+</pre>
+
+
+<h3>Example</h3>
+
+In this part of the example, we again print out the names of the
+personnel, but this time we use the
+<tt>make_const_projection_iterator()</tt> function to save some typing.
+
+<pre>
+  // continuing from the last example...
+
+  std::copy
+    (boost::make_const_projection_iterator&lt;select_name&gt;(personnel_list.begin()),
+     boost::make_const_projection_iterator&lt;select_name&gt;(personnel_list.end()),
+     std::ostream_iterator<std::string>(std::cout, "\n"));
+
+  return 0;
+}
+</pre>
+The output is:
+<pre>
+Barney
+Fred
+Wilma
+Betty
+</pre>
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->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;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>
+<!--  LocalWords:  html charset alt gif hpp BaseIterator const namespace struct
+ -->
+<!--  LocalWords:  ConstPointer ConstReference typename iostream int abcdefg
+ -->
+<!--  LocalWords:  sizeof  PairGen pre Siek htm AdaptableUnaryFunction
+ -->
+<!--  LocalWords:  ConstBaseIterator
+ -->

projection_iterator_example.cpp

@@ -9,7 +9,7 @@
 #include <iterator>
 #include <algorithm>
 #include <string>
-#include <boost/iterator/transform_iterator.hpp>
+#include <boost/iterator_adaptors.hpp>
 
 struct personnel_record {
   personnel_record(std::string n, int id) : m_name(n), m_ID(id) { }
@@ -19,7 +19,7 @@ struct personnel_record {
 
 struct select_name {
   typedef personnel_record argument_type;
-  typedef std::string const& result_type;
+  typedef std::string result_type;
   const std::string& operator()(const personnel_record& r) const {
     return r.m_name;
   }
@@ -30,7 +30,7 @@ struct select_name {
 
 struct select_ID {
   typedef personnel_record argument_type;
-  typedef int& result_type;
+  typedef int result_type;
   const int& operator()(const personnel_record& r) const {
     return r.m_ID;
   }
@@ -48,16 +48,11 @@ int main(int, char*[])
   personnel_list.push_back(personnel_record("Wilma", 62454));
   personnel_list.push_back(personnel_record("Betty", 20490));
 
-  // Example of using transform_iterator to print out the names in the
-  // personnel list using a projection.
+  // Example of using projection_iterator_generator
+  // to print out the names in the personnel list.
 
-  boost::transform_iterator<
-      select_name
-    , std::list<personnel_record>::iterator
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    , std::string
-#endif 
-  >
+  boost::projection_iterator_generator<select_name,
+    std::list<personnel_record>::iterator>::type
     personnel_first(personnel_list.begin()),
     personnel_last(personnel_list.end());
 
@@ -65,12 +60,14 @@ int main(int, char*[])
             std::ostream_iterator<std::string>(std::cout, "\n"));
   std::cout << std::endl;
   
-  // Example of using transform_iterator with const_iterators to
-  // assign new ID numbers to the personnel.
+  // Example of using projection_iterator_pair_generator
+  // to assign new ID numbers to the personnel.
   
-  boost::transform_iterator<
-      select_ID, std::list<personnel_record>::iterator
- > ID_first(personnel_list.begin()),
+  typedef boost::projection_iterator_pair_generator<select_ID,
+    std::list<personnel_record>::iterator,
+    std::list<personnel_record>::const_iterator> PairGen;
+
+  PairGen::iterator ID_first(personnel_list.begin()),
     ID_last(personnel_list.end());
 
   int new_id = 0;
@@ -79,25 +76,21 @@ int main(int, char*[])
     ++ID_first;
   }
 
-    boost::transform_iterator<
-      select_ID, std::list<personnel_record>::const_iterator, int const&
-    >
-    const_ID_first(personnel_list.begin()),
+  PairGen::const_iterator const_ID_first(personnel_list.begin()),
     const_ID_last(personnel_list.end());
 
   std::copy(const_ID_first, const_ID_last,
             std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
   std::cout << std::endl;
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  
   // Example of using make_const_projection_iterator()
   // to print out the names in the personnel list again.
-  std::copy(
-      boost::make_transform_iterator<select_name>(personnel_list.begin())
-    , boost::make_transform_iterator<select_name>(personnel_list.end())
-    , std::ostream_iterator<std::string>(std::cout, "\n"));
-#endif
   
+  std::copy
+    (boost::make_const_projection_iterator<select_name>(personnel_list.begin()),
+     boost::make_const_projection_iterator<select_name>(personnel_list.end()),
+     std::ostream_iterator<std::string>(std::cout, "\n"));
+
   return 0;
 }

reverse_iterator.htm

@@ -0,0 +1,331 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+
+<html>
+<head>
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+    <meta name="ProgId" content="FrontPage.Editor.Document">
+
+    <title>Reverse Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+    <img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align=
+    "center" width="277" height="86"> 
+
+    <h1>Reverse Iterator Adaptor</h1>
+    Defined in header <a href=
+    "../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a> 
+
+    <p>The reverse iterator adaptor flips the direction of a base iterator's
+    motion. Invoking <tt>operator++()</tt> moves the base iterator backward and
+    invoking <tt>operator--()</tt> moves the base iterator forward. The Boost
+    reverse iterator adaptor is better to use than the
+    <tt>std::reverse_iterator</tt> class in situations where pairs of
+    mutable/constant iterators are needed (e.g., in containers) because
+    comparisons and conversions between the mutable and const versions are
+    implemented correctly.
+
+    <h2>Synopsis</h2>
+<pre>
+namespace boost {
+  template &lt;class <a href=
+"http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>,
+            class Value, class Reference, class Pointer, class Category, class Distance&gt;
+  struct reverse_iterator_generator;
+  
+  template &lt;class <a href=
+"http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>&gt;
+  typename reverse_iterator_generator&lt;BidirectionalIterator&gt;::type
+  make_reverse_iterator(BidirectionalIterator base)  
+}
+</pre>
+    <hr>
+
+    <h2><a name="reverse_iterator_generator">The Reverse Iterator Type
+    Generator</a></h2>
+    The <tt>reverse_iterator_generator</tt> template is a <a href=
+    "../../more/generic_programming.html#type_generator">generator</a> of
+    reverse iterator types. The main template parameter for this class is the
+    base <tt>BidirectionalIterator</tt> type that is being adapted. In most
+    cases the associated types of the base iterator can be deduced using
+    <tt>std::iterator_traits</tt>, but in some situations the user may want to
+    override these types, so there are also template parameters for the base
+    iterator's associated types. 
+
+    <blockquote>
+<pre>
+template &lt;class <a href=
+"http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>,
+          class Value, class Reference, class Pointer, class Category, class Distance&gt;
+class reverse_iterator_generator
+{
+public:
+  typedef <tt><a href=
+"./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt;</tt> type; // the resulting reverse iterator type 
+};
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    In this example we sort a sequence of letters and then output the sequence
+    in descending order using reverse iterators. 
+
+    <blockquote>
+<pre>
+#include &lt;boost/config.hpp&gt;
+#include &lt;iostream&gt;
+#include &lt;algorithm&gt;
+#include &lt;boost/iterator_adaptors.hpp&gt;
+
+int main(int, char*[])
+{
+  char letters[] = "hello world!";
+  const int N = sizeof(letters)/sizeof(char) - 1;
+  std::cout &lt;&lt; "original sequence of letters:\t"
+      &lt;&lt; letters &lt;&lt; std::endl;
+
+  std::sort(letters, letters + N);
+
+  // Use reverse_iterator_generator to print a sequence
+  // of letters in reverse order.
+  
+  boost::reverse_iterator_generator&lt;char*&gt;::type
+    reverse_letters_first(letters + N),
+    reverse_letters_last(letters);
+
+  std::cout &lt;&lt; "letters in descending order:\t";
+  std::copy(reverse_letters_first, reverse_letters_last,
+      std::ostream_iterator&lt;char&gt;(std::cout));
+  std::cout &lt;&lt; std::endl;
+
+  // to be continued...
+</pre>
+    </blockquote>
+    The output is: 
+
+    <blockquote>
+<pre>
+original sequence of letters: hello world!
+letters in descending order:  wroolllhed! 
+</pre>
+    </blockquote>
+
+    <h3>Template Parameters</h3>
+
+    <table border>
+      <tr>
+        <th>Parameter
+
+        <th>Description
+
+      <tr>
+        <td><tt><a href=
+        "http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a></tt>
+        
+
+        <td>The iterator type being wrapped.
+
+      <tr>
+        <td><tt>Value</tt> 
+
+        <td>The value-type of the base iterator and the resulting reverse
+        iterator.<br>
+         <b>Default:</b><tt>std::iterator_traits&lt;BidirectionalIterator&gt;::value_type</tt>
+        
+
+      <tr>
+        <td><tt>Reference</tt> 
+
+        <td>The <tt>reference</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator*()</tt>.<br>
+         <b>Default:</b> If <tt>Value</tt> is supplied, <tt>Value&amp;</tt> is
+        used. Otherwise
+        <tt>std::iterator_traits&lt;BidirectionalIterator&gt;::reference</tt>
+        is used.
+
+      <tr>
+        <td><tt>Pointer</tt> 
+
+        <td>The <tt>pointer</tt> type of the resulting iterator, and in
+        particular, the result type of <tt>operator-&gt;()</tt>.<br>
+         <b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
+        otherwise
+        <tt>std::iterator_traits&lt;BidirectionalIterator&gt;::pointer</tt>.
+
+      <tr>
+        <td><tt>Category</tt> 
+
+        <td>The <tt>iterator_category</tt> type for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BidirectionalIterator&gt;::iterator_category</tt>
+        
+
+      <tr>
+        <td><tt>Distance</tt> 
+
+        <td>The <tt>difference_type</tt> for the resulting iterator.<br>
+         <b>Default:</b>
+        <tt>std::iterator_traits&lt;BidirectionalIterator&amp;gt::difference_type</tt>
+        
+    </table>
+
+    <h3>Concept Model</h3>
+    The indirect iterator will model whichever <a href=
+    "http://www.sgi.com/tech/stl/Iterators.html">standard iterator concept
+    category</a> is modeled by the base iterator. Thus, if the base iterator is
+    a model of <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> then so is the resulting indirect iterator. If the base
+    iterator models a more restrictive concept, the resulting indirect iterator
+    will model the same concept. The base iterator must be at least a <a href=
+    "http://www.sgi.com/tech/stl/BidirectionalIterator.html">Bidirectional
+    Iterator</a> 
+
+    <h3>Members</h3>
+    The reverse iterator type implements the member functions and operators
+    required of the <a href=
+    "http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access
+    Iterator</a> concept. In addition it has the following constructor: 
+
+    <blockquote>
+<pre>
+reverse_iterator_generator::type(const BidirectionalIterator&amp; it)
+</pre>
+    </blockquote>
+
+
+    <br>
+     <br>
+     
+    <hr>
+
+    <p>
+
+    <h2><a name="make_reverse_iterator">The Reverse Iterator Object
+    Generator</a></h2>
+    The <tt>make_reverse_iterator()</tt> function provides a more convenient
+    way to create reverse iterator objects. The function saves the user the
+    trouble of explicitly writing out the iterator types. 
+
+    <blockquote>
+<pre>
+template &lt;class BidirectionalIterator&gt;
+typename reverse_iterator_generator&lt;BidirectionalIterator&gt;::type
+make_reverse_iterator(BidirectionalIterator base);
+</pre>
+    </blockquote>
+
+    <h3>Example</h3>
+    In this part of the example we use <tt>make_reverse_iterator()</tt> to
+    print the sequence of letters in reverse-reverse order, which is the
+    original order. 
+
+    <blockquote>
+<pre>
+  // continuing from the previous example...
+
+  std::cout &lt;&lt; "letters in ascending order:\t";
+  std::copy(boost::make_reverse_iterator(reverse_letters_last),
+      boost::make_reverse_iterator(reverse_letters_first),
+      std::ostream_iterator&lt;char&gt;(std::cout));
+  std::cout &lt;&lt; std::endl;
+
+  return 0;
+}
+</pre>
+    </blockquote>
+    The output is: 
+
+    <blockquote>
+<pre>
+letters in ascending order:  !dehllloorw
+</pre>
+    </blockquote>
+    <hr>
+
+    <h2><a name="interactions">Constant/Mutable Iterator Interactions</a></h2>
+
+    <p>One failing of the standard <tt><a
+    href="http://www.sgi.com/tech/stl/ReverseIterator.html">reverse_iterator</a></tt>
+    adaptor is that it doesn't properly support interactions between adapted
+    <tt>const</tt> and non-<tt>const</tt> iterators. For example:
+<blockquote>
+<pre>
+#include &lt;vector&gt;
+
+template &lt;class T&gt; void convert(T x) {}
+
+// Test interactions of a matched pair of random access iterators
+template &lt;class Iterator, class ConstIterator&gt;
+void test_interactions(Iterator i, ConstIterator ci)
+{
+  bool eq = i == ci;               // comparisons
+  bool ne = i != ci;            
+  bool lt = i &lt; ci;
+  bool le = i &lt;= ci;
+  bool gt = i &gt; ci;
+  bool ge = i &gt;= ci;
+  std::size_t distance = i - ci;   // difference
+  ci = i;                          // assignment
+  ConstIterator ci2(i);            // construction
+  convert&lt;ConstIterator&gt;(i);       // implicit conversion
+}
+
+void f()
+{
+  typedef std::vector&lt;int&gt; vec;
+  vec v;
+  const vec&amp; cv;
+
+  test_interactions(v.begin(), cv.begin());   // <font color="#007F00">OK</font>
+  test_interactions(v.rbegin(), cv.rbegin()); // <font color="#FF0000">ERRORS ON EVERY TEST!!</font>
+</pre>
+</blockquote>
+Reverse iterators created with <tt>boost::reverse_iterator_generator</tt> don't have this problem, though:
+<blockquote>
+<pre>
+  typedef boost::reverse_iterator_generator&lt;vec::iterator&gt;::type ri;
+  typedef boost::reverse_iterator_generator&lt;vec::const_iterator&gt;::type cri;
+  test_interactions(ri(v.begin()), cri(cv.begin()));   // <font color="#007F00">OK!!</font>
+</pre>
+</blockquote>
+Or, more simply,
+<blockquote>
+<pre>
+  test_interactions(
+    boost::make_reverse_iterator(v.begin()), 
+    boost::make_reverse_iterator(cv.begin()));   // <font color="#007F00">OK!!</font>
+}
+</pre>
+</blockquote>
+
+<p>If you are wondering why there is no
+<tt>reverse_iterator_pair_generator</tt> in the manner of <tt><a
+href="projection_iterator.htm#projection_iterator_pair_generator">projection_iterator_pair_generator</a></tt>,
+the answer is simple: we tried it, but found that in practice it took
+<i>more</i> typing to use <tt>reverse_iterator_pair_generator</tt> than to
+simply use <tt>reverse_iterator_generator</tt> twice!<br><br>
+
+<hr>
+
+    
+    <p>Revised 
+    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->
+
+
+    <p>&copy; Copyright Jeremy Siek 2000. Permission to copy, use, modify, sell
+    and distribute this document is granted provided this copyright notice
+    appears in all copies. This document is provided "as is" without express or
+    implied warranty, and with no claim as to its suitability for any purpose. 
+    <!--  LocalWords:  html charset alt gif hpp BidirectionalIterator const namespace struct
+         -->
+     
+    <!--  LocalWords:  ConstPointer ConstReference typename iostream int abcdefg
+         -->
+     <!--  LocalWords:  sizeof  PairGen pre Siek wroolllhed dehllloorw
+         -->
+</body>
+</html>
+

reverse_iterator_example.cpp

@@ -6,15 +6,19 @@
 #include <boost/config.hpp>
 #include <iostream>
 #include <algorithm>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/detail/iterator.hpp>
+#include <boost/iterator_adaptors.hpp>
 
-//boost::detail::iterator_traits
 int main(int, char*[])
 {
   char letters_[] = "hello world!";
   const int N = sizeof(letters_)/sizeof(char) - 1;
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+  // Assume there won't be proper iterator traits for pointers. This
+  // is just a wrapper for char* which has the right traits.
+  typedef boost::iterator_adaptor<char*, boost::default_iterator_policies, char> base_iterator;
+#else
   typedef char* base_iterator;
+#endif
   base_iterator letters(letters_);
   
   std::cout << "original sequence of letters:\t"
@@ -25,7 +29,7 @@ int main(int, char*[])
   // Use reverse_iterator_generator to print a sequence
   // of letters in reverse order.
   
-  boost::reverse_iterator<base_iterator>
+  boost::reverse_iterator_generator<base_iterator>::type
     reverse_letters_first(letters + N),
     reverse_letters_last(letters);
 

shared_container_iterator.html

@@ -18,23 +18,22 @@ Defined in header
 <a href="../../boost/shared_container_iterator.hpp">boost/shared_container_iterator.hpp</a>
 
 <p>
-The purpose of the shared container iterator is to attach the lifetime
-of a container to the lifetime of its iterators. In other words, the
-container will not be deleted until after all its iterators are
-destroyed.  The shared container iterator is typically used to
-implement functions that return iterators over a range of objects that
-only need to exist for the lifetime of the iterators.  By returning a
-pair of shared iterators from a function, the callee can return a
-heap-allocated range of objects whose lifetime is automatically managed.
+The purpose of the shared container iterator is to attach the lifetime 
+of a container to the lifetime of its iterators. In other words, 
+the container will be deleted after the last iterator is destroyed.   
+The shared container iterator is typically used to implement functions 
+that return iterators over a
+range of objects that will only be needed for the lifetime of
+the iterators.  By returning a pair of shared iterators from a
+function, the callee can ensure that the underlying container's 
+lifetime will be properly managed.
 <p>
-The shared container iterator augments an iterator over a shared
-container.  It maintains a reference count on the shared 
-container. If only shared container iterators hold references to
-the container, the container's lifetime will end when the last shared
-container iterator over it is destroyed.  In any case, the shared
-container is guaranteed to persist beyond the lifetime of all
-the iterators. In all other ways, the
-shared container iterator behaves the same as its base iterator.
+The shared container iterator augments an iterator into a shared
+container with a reference counted pointer to the container. 
+Assuming no other references exist to the container, it will be
+destroyed when the last shared container iterator is destroyed.
+In all other ways, the shared container iterator
+behaves the same as its base iterator.
 
 
 <h2>Synopsis</h2>
@@ -42,44 +41,49 @@ shared container iterator behaves the same as its base iterator.
 <pre>
 namespace boost {
   template &lt;typename <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>&gt;
-  class shared_container_iterator;
+  class shared_container_iterator_generator;
 
   template &lt;typename <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>&gt;
-  shared_container_iterator&lt;Container&gt;
+  typename shared_container_iterator_generator&lt;Container&gt;::type
   make_shared_container_iterator(typename Container::iterator base, 
     boost::shared_ptr&lt;Container&gt; const&amp; container);
 
-  std::pair&lt;
-    typename shared_container_iterator&lt;Container&gt;,
-    typename shared_container_iterator&lt;Container&gt;
+  std::pair&lt
+    typename shared_container_iterator_generator&lt;Container&gt;::type,
+    typename shared_container_iterator_generator&lt;Container&gt;::type
   &gt;
   make_shared_container_range(boost::shared_ptr&lt;Container&gt; const&amp; container);
+
 }
 </pre>
 
 <hr>
 
-<h2><a name="generator">The Shared Container Iterator Type</a></h2>
+<h2><a name="generator">The Shared Container Iterator Type Generator</a></h2>
 
-<pre>
-template &lt;typename Container&gt; class shared_container_iterator;
-</pre>
-
-The class template <tt>shared_container_iterator</tt> 
-is the shared container iterator type.  The <tt>Container</tt> template
-type argument must model the
+The class <tt>shared_container_iterator_generator</tt> is a helper
+class to construct a shared container iterator type.  The template
+parameter for this class is a type that models the 
 <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>
 concept.
 
+<pre>
+template &lt;typename Container&gt;
+class shared_container_iterator_generator
+{
+public:
+    typedef <a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt; type;
+};
+</pre>
+
 <h3>Example</h3>
 
 <p>
-The following example illustrates how to create an iterator that 
+The following example illustrates how to use the
+<tt>shared_counter_iterator_generator</tt> to create an iterator that 
 regulates the lifetime of a reference counted <tt>std::vector</tt>.
-Though the original shared pointer <tt>ints</tt> ceases to exist
-after <tt>set_range()</tt> returns, the
-<tt>shared_counter_iterator</tt> objects maintain references to the
-      underlying vector and thereby extend the container's lifetime.
+Though the original <tt>shared_ptr</tt> to the vector ceases to exist, the
+<tt>shared_counter_iterator</tt>s extend the lifetime of the container.
 <p>
 <a href="./shared_iterator_example1.cpp">shared_iterator_example1.cpp</a>:
 <PRE>
@@ -89,7 +93,7 @@ after <tt>set_range()</tt> returns, the
 <font color="#008040">#include &lt;iostream&gt;</font>
 <font color="#008040">#include &lt;vector&gt;</font>
 
-<B>typedef</B> boost::shared_container_iterator&lt; std::vector&lt;<B>int</B>&gt; &gt; iterator;
+<B>typedef</B> boost::shared_container_iterator_generator&lt; std::vector&lt;<B>int</B>&gt; &gt;::type iterator;
 
 
 <B>void</B> set_range(iterator& i, iterator& end)  {
@@ -146,9 +150,12 @@ concept.
 
 <h3>Model of</h3>
 
-The <tt>shared_container_iterator<Container></tt> type models the
+The shared container iterator adaptor (the type
+<tt>shared_container_iterator_generator<...>::type</tt>) models the
 same iterator concept as the base iterator
-    (<tt>Container::iterator</tt>).
+    (<tt>Container::iterator</tt>) up to 
+<a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random 
+      Access Iterator</a>.
 
 <h3>Members</h3>
 
@@ -159,8 +166,8 @@ concept, though only operations defined for the base iterator will be valid.
 In addition it has the following constructor:
 
 <pre>
-shared_container_iterator(Container::iterator const&amp; it,
-                          boost::shared_ptr&lt;Container&gt; const&amp; container)
+shared_container_iterator_generator::type(Container::iterator const&amp; it,
+                                          boost::shared_ptr&lt;Container&gt; const&amp; container)
 </pre>
 
 <p>
@@ -172,15 +179,16 @@ shared_container_iterator(Container::iterator const&amp; it,
 
 <pre>
 template &lt;typename Container&gt;
-shared_container_iterator&lt;Container&gt;
+typename shared_container_iterator_generator&lt;AdaptableUnaryFunction,BaseIterator&gt;::type
 make_shared_container_iterator(Container::iterator base,
                                boost::shared_ptr&lt;Container&gt; const&amp; container)
 </pre>
 
-This function provides an alternative to directly constructing a
-shared container iterator.  Using the object generator, a shared
-container iterator can be created and passed to a function without
-explicitly specifying its type.
+This function provides an alternative to using the shared container
+iterator type generator to create the iterator type before
+construction. Using the object generator, a shared container iterator
+can be created and passed to a function without explicitly specifying
+its type.
 
 <h3>Example</h3>
 
@@ -238,16 +246,16 @@ explicitly named. The output from this example is the same as the previous.
 <pre>
 template &lt;typename Container&gt;
 std::pair&lt
-  shared_container_iterator&lt;Container&gt;,
-  shared_container_iterator&lt;Container&gt;
+  typename shared_container_iterator_generator&lt;Container&gt;::type,
+  typename shared_container_iterator_generator&lt;Container&gt;::type
 &gt;
 make_shared_container_range(boost::shared_ptr&lt;Container&gt; const&amp; container);
 </pre>
 
-Class <tt>shared_container_iterator</tt> is meant primarily to return,
-using iterators, a range of values that we can guarantee will be alive as 
+Class <tt>shared_container_iterator</tt> is meant primarily to return
+via iterators a range of values that we can guarantee will be alive as 
 long as the iterators are. This is a convenience
-function to do just that. It is equivalent to
+function to do just that. This function is equivalent to
 
 <pre>
 std::make_pair(make_shared_container_iterator(container-&gt;begin(),container),
@@ -257,7 +265,7 @@ std::make_pair(make_shared_container_iterator(container-&gt;begin(),container),
 <h3>Example</h3>
 
 In the following example, a range of values is returned as a pair of
-<tt>shared_container_iterator</tt> objects.  
+<tt>shared_container_iterator</tt>s.  
 
 
 <p>
@@ -272,9 +280,10 @@ In the following example, a range of values is returned as a pair of
 <font color="#008040">#include &lt;vector&gt;</font>
 
 
-<B>typedef</B> boost::shared_container_iterator&lt; std::vector&lt;<B>int</B>&gt; &gt; iterator; 
+<B>typedef</B> boost::shared_container_iterator_generator&lt; std::vector&lt;<B>int</B>&gt; &gt;::type 
+  function_iterator;
 
-std::pair&lt;iterator,iterator&gt;
+std::pair&lt;function_iterator,function_iterator&gt;
 return_range() {
   boost::shared_ptr&lt; std::vector&lt;<B>int</B>&gt; &gt; range(<B>new</B> std::vector&lt;<B>int</B>&gt;());
   range-&gt;push_back(<font color="#0000A0">0</font>);
@@ -290,7 +299,7 @@ return_range() {
 <B>int</B> main() {
 
 
-  iterator i,end;
+  function_iterator i,end;
   
   boost::tie(i,end) = return_range();
 
@@ -310,12 +319,13 @@ the previous two.
 
 <hr>
 <!-- hhmts start -->
-Last modified: Mon Aug 11 11:27:03 EST 2003
+Last modified: Wed Sep  4 15:52:17 EST 2002
 <!-- hhmts end -->
-<p><EFBFBD> Copyright 2003 The Trustees of Indiana University.
- Use, modification and distribution is subject to the Boost Software 
- License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http:www.boost.org/LICENSE_1_0.txt)</p>
+<p><EFBFBD> Copyright Ronald Garcia 2002. 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>
 

shared_iterator_example1.cpp

@@ -1,8 +1,7 @@
-// Copyright 2003 The Trustees of Indiana University.
-
-// Use, modification and distribution is subject to the Boost Software 
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright Ronald Garcia 2002. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
 
 #include "boost/shared_container_iterator.hpp"
 #include "boost/shared_ptr.hpp"
@@ -10,7 +9,8 @@
 #include <iostream>
 #include <vector>
 
-typedef boost::shared_container_iterator< std::vector<int> > iterator;
+typedef boost::shared_container_iterator_generator< std::vector<int> >::type
+  iterator;
 
 
 void set_range(iterator& i, iterator& end)  {

shared_iterator_example2.cpp

@@ -1,8 +1,7 @@
-// Copyright 2003 The Trustees of Indiana University.
-
-// Use, modification and distribution is subject to the Boost Software 
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright Ronald Garcia 2002. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
 
 #include "boost/shared_container_iterator.hpp"
 #include "boost/shared_ptr.hpp"
@@ -34,7 +33,7 @@ int main() {
     ints->push_back(5);
 
     print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
-                   boost::make_shared_container_iterator(ints->end(),ints));
+		   boost::make_shared_container_iterator(ints->end(),ints));
   }
   
 

shared_iterator_example3.cpp

@@ -1,8 +1,7 @@
-// Copyright 2003 The Trustees of Indiana University.
-
-// Use, modification and distribution is subject to the Boost Software 
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright Ronald Garcia 2002. Permission to copy, use, modify, sell and
+// distribute this software is granted provided this copyright notice appears
+// in all copies. This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
 
 #include "boost/shared_container_iterator.hpp"
 #include "boost/shared_ptr.hpp"
@@ -12,9 +11,10 @@
 #include <vector>
 
 
-typedef boost::shared_container_iterator< std::vector<int> > iterator;
+typedef boost::shared_container_iterator_generator< std::vector<int> >::type 
+  function_iterator;
 
-std::pair<iterator,iterator>
+std::pair<function_iterator,function_iterator>
 return_range() {
   boost::shared_ptr< std::vector<int> > range(new std::vector<int>());
   range->push_back(0);
@@ -30,7 +30,7 @@ return_range() {
 int main() {
 
 
-  iterator i,end;
+  function_iterator i,end;
   
   boost::tie(i,end) = return_range();
 

shared_iterator_test.cpp

@@ -1,64 +0,0 @@
-// Copyright 2003 The Trustees of Indiana University.
-
-// Use, modification and distribution is subject to the Boost Software 
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-//  Shared container iterator adaptor 
-//  Author: Ronald Garcia
-//  See http://boost.org/libs/utility/shared_container_iterator.html 
-//  for documentation. 
-
-//
-// shared_iterator_test.cpp - Regression tests for shared_container_iterator.
-//
-
-
-#include "boost/shared_container_iterator.hpp"
-#include "boost/shared_ptr.hpp"
-#include <vector>
-#include <cassert>
-
-struct resource {
-  static int count;
-  resource() { ++count; }
-  resource(resource const&) { ++count; }
-  ~resource() { --count; }
-};
-int resource::count = 0;
-
-typedef std::vector<resource> resources_t;
-
-typedef boost::shared_container_iterator< resources_t > iterator;
-
-
-void set_range(iterator& i, iterator& end)  {
-
-  boost::shared_ptr< resources_t > objs(new resources_t());
-
-  for (int j = 0; j != 6; ++j)
-    objs->push_back(resource());
-  
-  i = iterator(objs->begin(),objs);
-  end = iterator(objs->end(),objs);
-  assert(resource::count == 6);
-}
-
-
-int main() {
-
-  assert(resource::count == 0);
-  
-  {
-    iterator i;
-    {
-      iterator end;
-      set_range(i,end);
-      assert(resource::count == 6);
-    }
-    assert(resource::count == 6);
-  }
-  assert(resource::count == 0);
-  
-  return 0;
-}

test/Jamfile

@@ -1,43 +0,0 @@
-# Copyright David Abrahams 2003. 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.
-
-# For more information, see http://www.boost.org/
-
-
-# Testing Jamfile autogenerated from XML source
-subproject libs/utility/test ;
-
-# bring in rules for testing
-import testing ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-local test_monitor = <lib>@boost/libs/test/build/boost_test_exec_monitor ;
-
-test-suite utility
-    : 
-        [ run ../iterator_traits_test.cpp ]
-        [ run ../iterators_test.cpp $(test_monitor) ]
-        [ compile-fail ../noncopyable_test.cpp ]
-        [ run ../numeric_traits_test.cpp ]
-        [ run ../operators_test.cpp $(test_monitor) ]
-        [ run ../binary_search_test.cpp $(test_monitor) ]
-        [ run ../call_traits_test.cpp : -u ]
-        [ compile-fail ../checked_delete_test.cpp ]
-        [ run ../compressed_pair_test.cpp $(test_monitor) : -u ]
-        [ run ../addressof_test.cpp $(test_monitor) ]
-        [ run ../ref_test.cpp $(test_monitor) ]
-        [ run ../enable_if_constructors.cpp $(test_monitor) ]
-        [ run ../enable_if_dummy_arg_disambiguation.cpp $(test_monitor) ]
-        [ run ../enable_if_lazy.cpp $(test_monitor) ]
-        [ run ../enable_if_lazy_test.cpp $(test_monitor) ]
-        [ run ../enable_if_member_templates.cpp $(test_monitor) ]
-        [ run ../enable_if_namespace_disambiguation.cpp $(test_monitor) ]
-        [ run ../enable_if_no_disambiguation.cpp $(test_monitor) ]
-        [ run ../enable_if_partial_specializations.cpp $(test_monitor) ]
-        [ run next_prior_test.cpp $(test_monitor) ]          
-    ;

test/Jamfile.v2

@@ -1,33 +0,0 @@
-# Copyright David Abrahams 2003. 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.
-
-# For more information, see http://www.boost.org/
-
-# bring in rules for testing
-import testing ;
-
-test-suite utility
-    : 
-        [ run ../iterator_traits_test.cpp ]
-        [ run ../iterators_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ compile-fail ../noncopyable_test.cpp ]
-        [ run ../numeric_traits_test.cpp ]
-        [ run ../operators_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../binary_search_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../call_traits_test.cpp : -u ]
-        [ compile-fail ../checked_delete_test.cpp ]
-        [ run ../compressed_pair_test.cpp ../../test/build//boost_test_exec_monitor : -u ]
-        [ run ../addressof_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../ref_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_constructors.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_dummy_arg_disambiguation.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_lazy.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_lazy_test.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_member_templates.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_namespace_disambiguation.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_no_disambiguation.cpp ../../test/build//boost_test_exec_monitor ]
-        [ run ../enable_if_partial_specializations.cpp ../../test/build//boost_test_exec_monitor ]
-    ;

test/next_prior_test.cpp

@@ -1,79 +0,0 @@
-// Boost test program for next() and prior() utilities.
-
-// Copyright 2003 Daniel Walker.  Use, modification, and distribution
-// are subject to the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or a copy at
-// http://www.boost.org/LICENSE_1_0.txt.)
-
-// See http://www.boost.org/libs/utility for documentation.
-
-// Revision History 13 Dec 2003 Initial Version (Daniel Walker)
-
-// next() and prior() are replacements for operator+ and operator- for
-// non-random-access iterators. The semantics of these operators are
-// such that after executing j = i + n, std::distance(i, j) equals
-// n. Tests are provided to ensure next() has the same
-// result. Parallel tests are provided for prior(). The tests call
-// next() and prior() several times. next() and prior() are very
-// simple functions, though, and it would be very strange if these
-// tests were to fail.
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-
-#include <list>
-#include <vector>
-
-#include <boost/next_prior.hpp>
-
-template<class RandomAccessIterator, class ForwardIterator>
-bool plus_one_test(RandomAccessIterator first, RandomAccessIterator last, ForwardIterator first2)
-{
-    RandomAccessIterator i = first;
-    ForwardIterator j = first2;
-    while(i != last)
-        i = i + 1, j = boost::next(j);
-    return std::distance(first, i) == std::distance(first2, j);
-}
-
-template<class RandomAccessIterator, class ForwardIterator>
-bool plus_n_test(RandomAccessIterator first, RandomAccessIterator last, ForwardIterator first2)
-{
-    RandomAccessIterator i = first;
-    ForwardIterator j = first2;
-    for(int n = 0; i != last; ++n)
-        i = first + n, j = boost::next(first2, n);
-    return std::distance(first, i) == std::distance(first2, j);
-}
-
-template<class RandomAccessIterator, class BidirectionalIterator>
-bool minus_one_test(RandomAccessIterator first, RandomAccessIterator last, BidirectionalIterator last2)
-{
-    RandomAccessIterator i = last;
-    BidirectionalIterator j = last2;
-    while(i != first)
-        i = i - 1, j = boost::prior(j);
-    return std::distance(i, last) == std::distance(j, last2);
-}
-
-template<class RandomAccessIterator, class BidirectionalIterator>
-bool minus_n_test(RandomAccessIterator first, RandomAccessIterator last, BidirectionalIterator last2)
-{
-    RandomAccessIterator i = last;
-    BidirectionalIterator j = last2;
-    for(int n = 0; i != first; ++n)
-        i = last - n, j = boost::prior(last2, n);
-    return std::distance(i, last) == std::distance(j, last2);
-}
-
-int test_main(int, char*[])
-{
-    std::vector<int> x(8);
-    std::list<int> y(x.begin(), x.end());
-
-    BOOST_REQUIRE(plus_one_test(x.begin(), x.end(), y.begin()));
-    BOOST_REQUIRE(plus_n_test(x.begin(), x.end(), y.begin()));
-    BOOST_REQUIRE(minus_one_test(x.begin(), x.end(), y.end()));
-    BOOST_REQUIRE(minus_n_test(x.begin(), x.end(), y.end()));
-    return 0;
-}

tie.html

@@ -0,0 +1,143 @@
+<HTML>
+<!--
+  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine  2000
+  --
+  -- Permission to use, copy, modify, distribute and sell this software
+  -- and its documentation for any purpose is hereby granted without fee,
+  -- provided that the above copyright notice appears in all copies and
+  -- that both that copyright notice and this permission notice appear
+  -- in supporting documentation.  We make no
+  -- representations about the suitability of this software for any
+  -- purpose.  It is provided "as is" without express or implied warranty.
+  -->
+<Head>
+<Title>Boost Tie</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+	ALINK="#ff0000"> 
+<IMG SRC="../../c++boost.gif" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:tie"></A>
+<TT>tie</TT>
+</H1>
+
+<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);
+</PRE>
+
+<P>
+This is a utility function that makes it more convenient to work with
+a function which returns a std::pair&lt;&gt;. The effect of the <TT>tie()</TT>
+function is to allow the assignment of the two values of the pair to
+two separate variables. The idea for this comes from Jaakko
+J&#228;rvi's Binders&nbsp;[<A
+HREF="../graph/doc/bibliography.html#jaakko_tuple_assign">1</A>].
+
+<P>
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../boost/utility.hpp"><TT>boost/utility.hpp</TT></a>
+
+<P>
+
+<H3>Example</H3>
+
+<P>
+An example of using the <TT>tie()</TT> function with the
+<TT>vertices()</TT> function, which returns a pair of
+type <TT>std::pair&lt;vertex_iterator,vertex_iterator&gt;</TT>.  The
+pair of iterators is assigned to the iterator variables <TT>i</TT> and
+<TT>end</TT>.
+
+<P>
+<PRE>
+  graph_traits&lt; adjacency_list&lt;&gt; &gt;::vertex_iterator i, end;
+  for(tie(i,end) = vertices(G); i != end; ++i)
+    // ...
+</PRE>
+
+<P>
+Here is another example that uses <TT>tie()</TT> for handling operations with <a
+href="http://www.sgi.com/tech/stl/set.html"><TT>std::set</TT></a>.
+
+<P>
+<PRE>
+#include &lt;set&gt;
+#include &lt;algorithm&gt;
+#include &lt;iostream&gt;
+#include &lt;boost/utility.hpp&gt;
+
+int
+main(int, char*[])
+{
+  {
+    typedef std::set&lt;int&gt; SetT;
+    SetT::iterator i, end;
+    bool inserted;
+    
+    int vals[5] = { 5, 2, 4, 9, 1 };
+    SetT s(vals, vals + 5);
+    
+    // Using tie() with a return value of pair&lt;iterator,bool&gt;
+
+    int new_vals[2] = { 3, 9 };
+
+    for (int k = 0; k &lt; 2; ++k) {
+      boost::tie(i,inserted) = s.insert(new_vals[k]);
+      if (!inserted)
+        std::cout &lt;&lt; *i &lt;&lt; &quot; was already in the set.&quot; &lt;&lt; std::endl;
+      else
+        std::cout &lt;&lt; *i &lt;&lt; &quot; successfully inserted.&quot; &lt;&lt; std::endl;    
+    }
+  }    
+  {
+    int* i, *end;
+    int vals[6] = { 5, 2, 4, 4, 9, 1 };
+    std::sort(vals, vals + 6);
+
+    // Using tie() with a return value of pair&lt;iterator,iterator&gt;
+
+    boost::tie(i,end) = std::equal_range(vals, vals + 6, 4);
+    std::cout &lt;&lt; &quot;There were &quot; &lt;&lt; std::distance(i,end)
+              &lt;&lt; &quot; occurrences of &quot; &lt;&lt; *i &lt;&lt; &quot;.&quot; &lt;&lt; std::endl;
+    // Footnote: of course one would normally just use std::count()
+    // to get this information, but that would spoil the example :)
+  }
+  return 0;
+}
+</PRE>
+The output is:
+<PRE>
+  3 successfully inserted.
+  9 was already in the set.
+  There were 2 occurrences of 4.
+</PRE>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy 2000</TD><TD>
+<a HREF="../../people/jeremy_siek.htm">Jeremy Siek</a>,
+Univ.of Notre Dame (<A
+HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
+<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
+<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
+Univ.of Notre Dame (<A
+HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

tie_example.cpp

@@ -0,0 +1,64 @@
+//  (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+//
+// This is an example demonstrating how to use the tie() function.
+// The purpose of tie() is to make it easiery to deal with std::pair
+// return values.
+//
+// Contributed by Jeremy Siek
+//
+// Sample output
+//
+// 3 successfully inserted.
+// 9 was already in the set.
+// There were 2 occurrences of 4.
+
+#include <set>
+#include <algorithm>
+#include <iostream>
+#include <iterator>   // std::distance
+// 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;
+    bool inserted;
+    
+    int vals[5] = { 5, 2, 4, 9, 1 };
+    SetT s(vals, vals + 5);
+    
+    // Using tie() with a return value of pair<iterator,bool>
+
+    int new_vals[2] = { 3, 9 };
+
+    for (int k = 0; k < 2; ++k) {
+      boost::tie(i,inserted) = s.insert(new_vals[k]);
+      if (!inserted)
+        std::cout << *i << " was already in the set." << std::endl;
+      else
+        std::cout << *i << " successfully inserted." << std::endl;    
+    }
+  }    
+  {
+    int* i, *end;
+    int vals[6] = { 5, 2, 4, 4, 9, 1 };
+    std::sort(vals, vals + 6);
+
+    // Using tie() with a return value of pair<iterator,iterator>
+
+    boost::tie(i,end) = std::equal_range(vals, vals + 6, 4);
+    std::cout << "There were " << std::distance(i,end)
+              << " 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 :)
+  }
+  return 0;
+}

transform_iterator.htm

@@ -0,0 +1,223 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<title>Transform Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
+align="center" width="277" height="86">
+
+<h1>Transform Iterator Adaptor</h1>
+
+Defined in header
+<a href="../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
+
+<p>
+The transform iterator adaptor augments an iterator by applying some
+function object to the result of dereferencing the iterator. In other
+words, the <tt>operator*</tt> of the transform iterator first
+dereferences the base iterator, passes the result of this to the
+function object, and then returns the result. The following
+<b>pseudo-code</b> shows the basic idea:
+
+<pre>
+  value_type transform_iterator::operator*() const {
+    return this->f(*this->base_iterator);
+  }
+</pre>
+
+All of the other operators of the transform iterator behave in the
+same fashion as those of the base iterator.
+
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+  class transform_iterator_generator;
+
+  template &lt;class <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">AdaptableUnaryFunction</a>, class BaseIterator&gt;
+  typename transform_iterator_generator&lt;AdaptableUnaryFunction,Iterator&gt;::type
+  make_transform_iterator(BaseIterator base, const AdaptableUnaryFunction&amp; f = AdaptableUnaryFunction());
+}
+</pre>
+
+<hr>
+
+<h2><a name="transform_iterator_generator">The Transform Iterator Type
+Generator</a></h2>
+
+The class <tt>transform_iterator_generator</tt> is a helper class whose
+purpose is to construct a transform iterator type.  The template
+parameters for this class are the <tt>AdaptableUnaryFunction</tt> function object
+type and the <tt>BaseIterator</tt> type that is being wrapped.
+
+<pre>
+template &lt;class AdaptableUnaryFunction, class Iterator&gt;
+class transform_iterator_generator
+{
+public:
+    typedef <a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt;...&gt; type;
+};
+</pre>
+
+<h3>Example</h3>
+
+<p>
+The following is an example of how to use the
+<tt>transform_iterator_generator</tt> class to iterate through a range
+of numbers, multiplying each of them by 2 when they are dereferenced.
+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>
+#include &lt;functional&gt;
+#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 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, 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)
+    std::cout &lt;&lt; *i++ &lt;&lt; " ";
+  std::cout &lt;&lt; std::endl;
+
+  // to be continued...
+</PRE>
+The output from this part is:
+<pre>
+2 4 6 8 10 12 14 16
+</pre>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><a
+href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html"><tt>AdaptableUnaryFunction</tt></a></TD>
+<TD>The function object that transforms each element in the iterator
+range.  The <tt>argument_type</tt> of the function object must match
+the value type of the base iterator.  The <tt>result_type</tt> of the
+function object will be the resulting iterator's
+<tt>value_type</tt>. If you want the resulting iterator to behave as
+an iterator, the result of the function should be solely a function of
+its argument. 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>
+<TD><tt>BaseIterator</tt></TD>
+<TD>The iterator type being wrapped. This type must at least be a model
+ of the <a href="http://www.sgi.com/tech/stl/InputIterator">InputIterator</a> concept.</TD>
+</TR>
+
+</Table>
+
+<h3>Model of</h3>
+
+The transform iterator adaptor (the type
+<tt>transform_iterator_generator<...>::type</tt>) is a model of <a
+href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a><a href="#1">[1]</a>.
+
+
+<h3>Members</h3>
+
+The transform iterator type implements the member functions and
+operators required of the <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
+concept, except that the <tt>reference</tt> type is the same as the <tt>value_type</tt>
+so <tt>operator*()</tt> returns by-value. In addition it has the following constructor:
+
+<pre>
+transform_iterator_generator::type(const BaseIterator&amp; it,
+                                   const AdaptableUnaryFunction&amp; f = AdaptableUnaryFunction())
+</pre>
+
+<p>
+<hr>
+<p>
+
+
+<h2><a name="make_transform_iterator">The Transform Iterator Object Generator</a></h2>
+
+<pre>
+template &lt;class AdaptableUnaryFunction, class BaseIterator&gt;
+typename transform_iterator_generator&lt;AdaptableUnaryFunction,BaseIterator&gt;::type
+make_transform_iterator(BaseIterator base,
+                        const AdaptableUnaryFunction&amp; f = AdaptableUnaryFunction());
+</pre>
+
+This function provides a convenient way to create transform iterators.
+
+<h3>Example</h3>
+
+Continuing from the previous example, we use the <tt>make_transform_iterator()</tt>
+function to add four to each element of the array.
+
+<pre>
+  std::cout << "adding 4 to each element in the array:" << std::endl;
+
+  std::copy(boost::make_transform_iterator(x, 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;
+
+  return 0;
+}
+</pre>
+The output from this part is:
+<pre>
+5 6 7 8 9 10 11 12
+</pre>
+
+<h3>Notes</h3>
+
+
+<a name="1">[1]</a> If the base iterator is a model of <a
+href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
+then the transform iterator will also suppport most of the
+functionality required by the Random Access Iterator concept. However, a
+transform iterator can never completely satisfy the requirements for
+<a
+href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>
+(or of any concepts that refine Forward Iterator, which includes
+Random Access Iterator and Bidirectional Iterator) since the <tt>operator*</tt> of the transform
+iterator always returns by-value.
+
+
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->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;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>

transform_iterator_example.cpp

@@ -7,7 +7,7 @@
 #include <functional>
 #include <algorithm>
 #include <iostream>
-#include <boost/iterator/transform_iterator.hpp>
+#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
@@ -53,7 +53,7 @@ main(int, char*[])
   const int N = sizeof(x)/sizeof(int);
 
   typedef boost::binder1st< std::multiplies<int> > Function;
-  typedef boost::transform_iterator<Function, int*> doubling_iterator;
+  typedef boost::transform_iterator_generator<Function, int*>::type doubling_iterator;
 
   doubling_iterator i(x, boost::bind1st(std::multiplies<int>(), 2)),
     i_end(x + N, boost::bind1st(std::multiplies<int>(), 2));

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;
+}

utility.htm

@@ -22,6 +22,8 @@
 				Class <a href="#Class_noncopyable">noncopyable</a></li>
 			<li>
 				Function template <a href="#addressof">addressof()</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 
@@ -40,33 +42,15 @@
 			<pre>template &lt;class T&gt;
 T next(T x) { return ++x; }
 
-template &lt;class T, class Distance&gt;
-T next(T x, Distance n)
-{
-    std::advance(x, n);
-    return x;
-}
-
-template &lt;class T&gt;
-T prior(T x) { return --x; }
-
-template &lt;class T, class Distance&gt;
-T prior(T x, Distance n)
-{
-    std::advance(x, -n);
-    return x;
-}</pre>
+template &lt;class X&gt;
+T prior(T x) { return --x; }</pre>
 		</blockquote>
 		<p>Usage is simple:</p>
 		<blockquote>
 			<pre>const std::list&lt;T&gt;::iterator p = get_some_iterator();
-const std::list&lt;T&gt;::iterator prev = boost::prior(p);
-const std::list&lt;T&gt;::iterator next = boost::next(prev, 2);</pre>
+const std::list&lt;T&gt;::iterator prev = boost::prior(p);</pre>
 		</blockquote>
-                <p>The distance from the given iterator should be supplied as an absolute value. For
-			example, the iterator four iterators prior to the given iterator <code>p</code>
-			may be obtained by <code>prior(p, 4)</code>.</p>
-		<p>Contributed by <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>.  Two-argument versions by Daniel Walker.</p>
+		<p>Contributed by <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>.</p>
 		<h2><a name="Class_noncopyable">Class noncopyable</a></h2>
 		<p>Class <strong>noncopyable</strong> is a base class.&nbsp; Derive your own class 
 			from <strong>noncopyable</strong> when you want to prohibit copy construction 
@@ -138,14 +122,16 @@ void f() {
 		</blockquote>
 		<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
--->23 December, 2003<!--webbot bot="Timestamp" endspan i-checksum="38582"
+-->09 January, 2003<!--webbot bot="Timestamp" endspan i-checksum="38582"
 -->
 		</p>
-		<p>&copy; Copyright boost.org 1999-2003. Permission to copy, use, modify, sell and distribute 
+		<p><EFBFBD> Copyright boost.org 1999-2002. 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>
+</html>