This commit was manufactured by cvs2svn to create tag

'Version_1_26_0'. [SVN r11842]
fix gcc looping (from Dave Abrahams)
2025-10-05 21:40:59 +02:00 · 2001-11-30 18:24:42 +00:00 · 2001-11-30 17:55:39 +00:00 · 2001-11-30 11:10:07 +00:00 · 2001-11-30 10:40:03 +00:00 · 2001-11-29 21:22:52 +00:00
22 changed files with 1396 additions and 234 deletions
--- a/call_traits_test.cpp
+++ b/call_traits_test.cpp
@@ -160,10 +160,10 @@ struct call_traits_checker<T[N]>

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

@@ -211,17 +211,14 @@ int main(int argc, char *argv[ ])
   c4(i);
   call_traits_checker<const int&> c5;
   c5(i);
-#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__MWERKS__)
+#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__MWERKS__) && !defined(__SUNPRO_CC)
   call_traits_checker<int[2]> c6;
   c6(a);
 #endif
 #endif

   check_wrap(wrap(2), 2);
-   // compiler can't deduce this for some reason:
-   //const char ca[4] = "abc";
-   //check_wrap(wrap(ca), ca);
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
   check_wrap(wrap(a), a);
   check_make_pair(test::make_pair(a, a), a, a);
 #endif
@@ -376,8 +373,10 @@ void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>:
   unused_variable(v3);
   unused_variable(v4);
   unused_variable(v5);
+#ifndef __BORLANDC__
   unused_variable(r2);
   unused_variable(cr2);
+#endif
   unused_variable(cr3);
   unused_variable(p2);
   unused_variable(p3);
@@ -392,7 +391,7 @@ template struct call_traits_test<int*>;
 #if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
 template struct call_traits_test<int&>;
 template struct call_traits_test<const int&>;
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
 template struct call_traits_test<int[2], true>;
 #endif
 #endif
@@ -400,7 +399,13 @@ template struct call_traits_test<int[2], true>;
 #ifdef BOOST_MSVC
 unsigned int expected_failures = 10;
 #elif defined(__SUNPRO_CC)
-unsigned int expected_failures = 11;
+#if(__SUNPRO_CC <= 0x520)
+unsigned int expected_failures = 14;
+#elif(__SUNPRO_CC <= 0x530)
+unsigned int expected_failures = 13;
+#else
+unsigned int expected_failures = 6;
+#endif
 #elif defined(__BORLANDC__)
 unsigned int expected_failures = 2;
 #elif defined(__GNUC__)
@@ -412,3 +417,4 @@ unsigned int expected_failures = 0;



+
--- a/counting_iterator_example.cpp
+++ b/counting_iterator_example.cpp
@@ -42,12 +42,13 @@ int main(int, char*[])

  // Use indirect iterator to print out numbers by accessing
  // them through the array of pointers.
+#ifndef BOOST_MSVC
  std::cout << "indirectly printing out the numbers from 0 to " 
 	    << N << std::endl;
  std::copy(boost::make_indirect_iterator(pointers.begin()),
 	    boost::make_indirect_iterator(pointers.end()),
 	    std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;
-  
+#endif
  return 0;
 }
--- a/generator_iterator.htm
+++ b/generator_iterator.htm
@@ -0,0 +1,150 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
+
+<html>
+<head>
+<title>Generator 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>Generator Iterator Adaptor</h1>
+Defined in header <a href="../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a> 
+<p>
+The generator iterator adaptor makes it easier to create custom input
+iterators from 0-ary functions and function objects.  The adaptor
+takes a
+<a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a>
+and creates a model of
+<a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.
+Each increment retrieves an item from the generator and makes it
+available to be retrieved by dereferencing.  The motivation for this
+iterator is that some concepts can be more naturally expressed as a
+generator, while most STL algorithms expect an iterator.  An example
+is the <a href="../random/index.html">Random Number</a> library.
+
+<h2>Synopsis</h2>
+
+<blockquote>
+<pre>
+namespace boost {
+  template &lt;class Generator&gt;
+  class generator_iterator_policies;
+
+  template &lt;class Generator&gt;
+  class generator_iterator_generator;
+
+  template &lt;class Generator&gt;
+  typename generator_iterator_generator&lt;Generator&gt;::type
+  make_generator_iterator(Generator &amp; gen);
+}
+</pre>
+</blockquote>
+
+<hr>
+
+<h2>The Generator Iterator Generator Class</h2>
+
+The class generator_iterator_generator is a helper class whose purpose
+is to construct a generator iterator type. The template parameter for
+this class is the Generator function object type that is being
+wrapped.  The generator iterator adaptor only holds a reference (or
+pointer) to the function object, therefore the function object must
+outlive the generator iterator adaptor constructed from it.
+
+<pre>
+template &lt;class Generator>
+class generator_iterator_generator
+{
+public:
+  typedef <a href="iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a>&lt...&gt; type; // the resulting generator iterator type 
+}
+</pre>
+
+
+<h3>Template Parameters</h3>
+
+<table border>
+<tr>
+<th>Parameter</th>
+<th>Description</th>
+</tr>
+
+<tr>
+<td><tt><a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt> 
+<td>The generator (0-ary function object) type being
+wrapped.  The return type of the function must be defined as
+<tt>Generator::result_type</tt>.  The function object must be a model
+of
+<a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a>.
+</td>
+</table>
+
+<h3>Concept Model</h3>
+The generator iterator class is a model of
+<a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.
+
+<h3>Members</h3>
+The generator iterator implements the member functions
+and operators required of the
+<a href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
+concept.
+
+<br>
+
+<hr>
+<h2><a name="make_generator_iterator">The Generator Iterator Object Generator</a></h2>
+
+The <tt>make_generator_iterator()</tt> function provides a
+convenient way to create generator iterator objects. The function
+saves the user the trouble of explicitly writing out the iterator
+types.
+
+<blockquote>
+<pre>
+template &lt;class Generator&gt;
+typename generator_iterator_generator&lt;Generator&gt;::type
+make_function_output_iterator(Generator &amp; gen);
+</pre>
+</blockquote>
+
+<hr>
+
+
+<h3>Example</h3>
+
+The following program shows how <code>generator_iterator</code>
+transforms a generator into an input iterator.
+
+<blockquote>
+<pre>
+#include &lt;iostream>
+#include &lt;boost/generator_iterator.hpp>
+
+class my_generator
+{
+public:
+  typedef int result_type;
+  my_generator() : state(0) { }
+  int operator()() { return ++state; }
+private:
+  int state;
+};
+
+int main()
+{
+  my_generator gen;
+  boost::generator_iterator&lt;my_generator> it(gen);
+  for(int i = 0; i &lt; 10; ++i, ++it)
+    std::cout &lt;&lt; *it &lt;&lt; std::endl;
+}
+</pre>
+</blockquote>
+
+<hr>
+
+Written by Jens Maurer.
+
+</body>
+</html>
--- a/include/boost/detail/call_traits.hpp
+++ b/include/boost/detail/call_traits.hpp
@@ -109,7 +109,7 @@ struct call_traits<T&const volatile>
   typedef T& param_type;  // hh removed const
 };
 #endif
-
+#ifndef __SUNPRO_CC
 template <typename T, std::size_t N>
 struct call_traits<T [N]>
 {
@@ -135,6 +135,7 @@ public:
   typedef const array_type& const_reference;
   typedef const T* const param_type;
 };
+#endif

 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 template <class T1, class T2>
--- a/include/boost/generator_iterator.hpp
+++ b/include/boost/generator_iterator.hpp
@@ -0,0 +1,73 @@
+// (C) Copyright Jens Maurer 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+//
+// Revision History:
+
+// 15 Nov 2001   Jens Maurer
+//      created.
+
+#ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+#define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+
+#include <boost/iterator_adaptors.hpp>
+#include <boost/ref.hpp>
+
+namespace boost {
+
+template<class Generator>
+class generator_iterator_policies
+{
+public:
+    generator_iterator_policies() { }
+
+    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 IteratorAdaptor&) const
+        { return 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:
+  typename Generator::result_type m_value;
+};
+
+template<class Generator>
+struct generator_iterator_generator
+{
+  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 typename generator_iterator_generator<Generator>::type
+make_generator_iterator(Generator & gen)
+{
+  typedef typename generator_iterator_generator<Generator>::type result_t;
+  return result_t(&gen);
+}
+
+} // namespace boost
+
+
+#endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+
--- a/include/boost/operators.hpp
+++ b/include/boost/operators.hpp
@@ -9,6 +9,11 @@
 //  See http://www.boost.org for most recent version including documentation.

 //  Revision History
+//  28 Sep 01 Factored out iterator operator groups.  (Daryle Walker)
+//  27 Aug 01 'left' form for non commutative operators added;
+//            additional classes for groups of related operators added;
+//            workaround for empty base class optimization
+//            bug of GCC 3.0 (Helmut Zeisel)
 //  25 Jun 01 output_iterator_helper changes: removed default template 
 //            parameters, added support for self-proxying, additional 
 //            documentation and tests (Aleksey Gurtovoy)
@@ -81,7 +86,14 @@
 namespace boost {
 namespace detail {

+// Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
+#if defined(__GNUCC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
+class empty_base {
+  bool dummy; 
+};
+#else
 class empty_base {};
+#endif

 } // namespace detail
 } // namespace boost
@@ -168,6 +180,13 @@ struct subtractable2 : B
     friend T operator-(T x, const U& y) { return x -= y; }
 };

+template <class T, class U, class B = ::boost::detail::empty_base>
+struct subtractable2_left : B
+{
+  friend T operator-(const U& x, const T& y)
+    { T result(x); return result -= y; }
+};
+
 template <class T, class B = ::boost::detail::empty_base>
 struct subtractable1 : B
 {
@@ -180,6 +199,13 @@ struct dividable2 : B
     friend T operator/(T x, const U& y) { return x /= y; }
 };

+template <class T, class U, class B = ::boost::detail::empty_base>
+struct dividable2_left : B
+{
+  friend T operator/(const U& x, const T& y)
+    { T result(x); return result /= y; }
+};
+
 template <class T, class B = ::boost::detail::empty_base>
 struct dividable1 : B
 {
@@ -192,6 +218,13 @@ struct modable2 : B
     friend T operator%(T x, const U& y) { return x %= y; }
 };

+template <class T, class U, class B = ::boost::detail::empty_base>
+struct modable2_left : B
+{
+  friend T operator%(const U& x, const T& y)
+    { T result(x); return result %= y; }
+};
+
 template <class T, class B = ::boost::detail::empty_base>
 struct modable1 : B
 {
@@ -463,12 +496,121 @@ struct shiftable1
    , right_shiftable1<T, B
      > > {};

+template <class T, class U, class B = ::boost::detail::empty_base>
+struct ring_operators2
+    : additive2<T, U
+    , subtractable2_left<T, U
+    , multipliable2<T, U, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct ring_operators1
+    : additive1<T
+    , multipliable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct ordered_ring_operators2
+    : ring_operators2<T, U
+    , totally_ordered2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct ordered_ring_operators1
+    : ring_operators1<T
+    , totally_ordered1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct field_operators2
+    : ring_operators2<T, U
+    , dividable2<T, U
+    , dividable2_left<T, U, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct field_operators1
+    : ring_operators1<T
+    , dividable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct ordered_field_operators2
+    : field_operators2<T, U
+    , totally_ordered2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct ordered_field_operators1
+    : field_operators1<T
+    , totally_ordered1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct euclidian_ring_operators2
+    : ring_operators2<T, U
+    , dividable2<T, U
+    , dividable2_left<T, U
+    , modable2<T, U
+    , modable2_left<T, U, B
+      > > > > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct euclidian_ring_operators1
+    : ring_operators1<T
+    , dividable1<T
+    , modable1<T, B
+      > > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base>
+struct ordered_euclidian_ring_operators2
+    : totally_ordered2<T, U
+    , euclidian_ring_operators2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct ordered_euclidian_ring_operators1
+    : totally_ordered1<T
+    , euclidian_ring_operators1<T, B
+      > > {};
+      
+template <class T, class P, class B = ::boost::detail::empty_base>
+struct input_iteratable
+    : equality_comparable1<T
+    , incrementable<T
+    , dereferenceable<T, P, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base>
+struct output_iteratable
+    : incrementable<T, B
+      > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base>
+struct forward_iteratable
+    : input_iteratable<T, P, B
+      > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base>
+struct bidirectional_iteratable
+    : forward_iteratable<T, P
+    , decrementable<T, B
+      > > {};
+
+template <class T, class P, class D, class R, class B = ::boost::detail::empty_base>
+struct random_access_iteratable
+    : bidirectional_iteratable<T, P
+    , totally_ordered1<T
+    , additive2<T, D
+    , indexable<T, D, R, B
+      > > > > {};
+
 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
 } // namespace boost
 #endif // BOOST_NO_OPERATORS_IN_NAMESPACE


-// BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE3 -
+// BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE4 -
 //
 // When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
 // operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
@@ -479,6 +621,7 @@ struct shiftable1
 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE

  // The template is already in boost so we have nothing to do.
+# define BOOST_IMPORT_TEMPLATE4(template_name)
 # define BOOST_IMPORT_TEMPLATE3(template_name)
 # define BOOST_IMPORT_TEMPLATE2(template_name)
 # define BOOST_IMPORT_TEMPLATE1(template_name)
@@ -489,6 +632,7 @@ struct shiftable1

     // Bring the names in with a using-declaration
     // to avoid stressing the compiler.
+#    define BOOST_IMPORT_TEMPLATE4(template_name) using ::template_name;
 #    define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name;
 #    define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
 #    define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
@@ -497,6 +641,10 @@ struct shiftable1

     // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
     // from working, we are forced to use inheritance for that compiler.
+#    define BOOST_IMPORT_TEMPLATE4(template_name)                                          \
+     template <class T, class U, class V, class W, class B = ::boost::detail::empty_base>  \
+     struct template_name : ::template_name<T, U, V, W, B> {};
+
 #    define BOOST_IMPORT_TEMPLATE3(template_name)                                 \
     template <class T, class U, class V, class B = ::boost::detail::empty_base>  \
     struct template_name : ::template_name<T, U, V, B> {};
@@ -542,6 +690,15 @@ template<class T> struct is_chained_base {

 } // namespace boost

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

 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

+#  define BOOST_OPERATOR_TEMPLATE4(template_name4) \
+        BOOST_IMPORT_TEMPLATE4(template_name4)
 #  define BOOST_OPERATOR_TEMPLATE3(template_name3) \
        BOOST_IMPORT_TEMPLATE3(template_name3)
 #  define BOOST_OPERATOR_TEMPLATE2(template_name2) \
@@ -632,8 +791,11 @@ BOOST_OPERATOR_TEMPLATE(equality_comparable)
 BOOST_OPERATOR_TEMPLATE(multipliable)
 BOOST_OPERATOR_TEMPLATE(addable)
 BOOST_OPERATOR_TEMPLATE(subtractable)
+BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
 BOOST_OPERATOR_TEMPLATE(dividable)
+BOOST_OPERATOR_TEMPLATE2(dividable2_left)
 BOOST_OPERATOR_TEMPLATE(modable)
+BOOST_OPERATOR_TEMPLATE2(modable2_left)
 BOOST_OPERATOR_TEMPLATE(xorable)
 BOOST_OPERATOR_TEMPLATE(andable)
 BOOST_OPERATOR_TEMPLATE(orable)
@@ -658,14 +820,27 @@ BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
 BOOST_OPERATOR_TEMPLATE(bitwise)
 BOOST_OPERATOR_TEMPLATE1(unit_steppable)
 BOOST_OPERATOR_TEMPLATE(shiftable)
+BOOST_OPERATOR_TEMPLATE(ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
+BOOST_OPERATOR_TEMPLATE(field_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
+BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
+BOOST_OPERATOR_TEMPLATE2(input_iteratable)
+BOOST_OPERATOR_TEMPLATE1(output_iteratable)
+BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
+BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
+BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)

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

 // The following 'operators' classes can only be used portably if the derived class
 // declares ALL of the required member operators.
@@ -699,20 +874,18 @@ template <class T,
          class P = V const *,
          class R = V const &>
 struct input_iterator_helper
-  : equality_comparable1<T
-  , incrementable<T
-  , dereferenceable<T, P
+  : input_iteratable<T, P
  , boost::iterator<std::input_iterator_tag, V, D, P, R
-    > > > > {};
+    > > {};

-template<class Derived>
+template<class T>
 struct output_iterator_helper
-  : boost::incrementable<Derived
+  : output_iteratable<T
  , boost::iterator<std::output_iterator_tag, void, void, void, void
  > >
 {
-  Derived& operator*()  { return static_cast<Derived&>(*this); }
-  Derived& operator++() { return static_cast<Derived&>(*this); }
+  T& operator*()  { return static_cast<T&>(*this); }
+  T& operator++() { return static_cast<T&>(*this); }
 };

 template <class T,
--- a/include/boost/ref.hpp
+++ b/include/boost/ref.hpp
@@ -1,16 +1,15 @@
 #ifndef BOOST_REF_HPP_INCLUDED
 #define BOOST_REF_HPP_INCLUDED

-#if _MSC_VER >= 1020
+#if _MSC_VER+0 >= 1020
 #pragma once
 #endif

 //
 //  ref.hpp - ref/cref, useful helper functions
 //
-//  Version 1.00.0003 (2001-08-22)
-//
 //  Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
+//  Copyright (C) 2001 Peter Dimov
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
@@ -40,16 +39,24 @@ private:
    reference_wrapper & operator= (reference_wrapper const &);
 };

-template<class T> inline reference_wrapper<T> ref(T & t)
+#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
+#define BOOST_REF_CONST
+#else
+#define BOOST_REF_CONST const
+#endif
+
+template<class T> inline reference_wrapper<T> BOOST_REF_CONST ref(T & t)
 { 
    return reference_wrapper<T>(t);
 }

-template<class T> inline reference_wrapper<T const> cref(T const & t)
+template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const & t)
 {
    return reference_wrapper<T const>(t);
 }

+#undef BOOST_REF_CONST
+
 } // namespace boost

 #endif // #ifndef BOOST_REF_HPP_INCLUDED
--- a/include/boost/utility_fwd.hpp
+++ b/include/boost/utility_fwd.hpp
@@ -26,12 +26,8 @@ template < typename MemberType, int UniqueID = 0 >

 class noncopyable;

-template < class A, class B >
-    class tied;
-
 // Also has a few function templates

-
 }  // namespace boost


--- a/indirect_iterator_example.cpp
+++ b/indirect_iterator_example.cpp
@@ -33,8 +33,8 @@ int main(int, char*[])

  char mutable_characters[N];
  char* pointers_to_mutable_chars[N];
-  for (int i = 0; i < N; ++i)
-    pointers_to_mutable_chars[i] = &mutable_characters[i];
+  for (int j = 0; j < N; ++j)
+    pointers_to_mutable_chars[j] = &mutable_characters[j];

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

+#ifndef BOOST_MSVC
  std::copy(boost::make_indirect_iterator(pointers_to_chars), 
 	    boost::make_indirect_iterator(pointers_to_chars + N),
 	    std::ostream_iterator<char>(std::cout, ","));
  std::cout << std::endl;
+#endif
  
  return 0;
 }
--- a/iter_traits_gen_test.cpp
+++ b/iter_traits_gen_test.cpp
@@ -4,7 +4,9 @@
 // "as is" without express or implied warranty, and with no claim as
 // to its suitability for any purpose.

-// 8 Mar 2001   Jeremy Siek
+// 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>
@@ -26,9 +28,8 @@ main()

  {
    typedef boost::iterator_adaptor<my_iter, boost::default_iterator_policies,
-      boost::iterator_traits_generator
-      ::reference<dummyT>
-      ::iterator_category<std::input_iterator_tag> > iter_type;
+      boost::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));
@@ -42,12 +43,11 @@ main()
  {
    typedef boost::iterator_adaptor<dummyT*,
      boost::default_iterator_policies,
-      boost::iterator_traits_generator
-        ::value_type<dummyT>
-        ::reference<const dummyT&>
-        ::pointer<const dummyT*> 
-        ::iterator_category<std::forward_iterator_tag>
-        ::difference_type<std::ptrdiff_t> > adaptor_type;
+      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);

--- a/iterator_adaptor_examples.cpp
+++ b/iterator_adaptor_examples.cpp
@@ -7,7 +7,7 @@
 #include <functional>
 #include <algorithm>
 #include <iostream>
-#include <boost/pending/iterator_adaptors.hpp>
+#include <boost/iterator_adaptors.hpp>
 #include <boost/pending/integer_range.hpp>

 int
@@ -21,8 +21,7 @@ main(int, char*[])
  int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };

  typedef std::binder1st< std::multiplies<int> > Function;
-  typedef boost::transform_iterator<Function, int*, 
-    boost::iterator<std::random_access_iterator_tag, int>
+  typedef boost::transform_iterator_generator<Function, int* 
  >::type doubling_iterator;

  doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
--- a/iterator_adaptor_test.cpp
+++ b/iterator_adaptor_test.cpp
@@ -9,6 +9,10 @@
 //  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
@@ -47,15 +51,20 @@

 #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 { };

@@ -97,6 +106,18 @@ 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()
 {
@@ -105,17 +126,61 @@ main()
  const int N = sizeof(array)/sizeof(dummyT);

  // sanity check, if this doesn't pass the test is buggy
-  boost::random_access_iterator_test(array,N,array);
+  boost::random_access_iterator_test(array, N, array);

  // Check that the policy concept checks and the default policy
  // implementation match up.
  boost::function_requires< 
     boost::RandomAccessIteratorPoliciesConcept<
-       boost::default_iterator_policies, int*,
+       boost::default_iterator_policies,
+       boost::iterator_adaptor<int*, boost::default_iterator_policies>,
       boost::iterator<std::random_access_iterator_tag, int, std::ptrdiff_t,
                      int*, int&>
      > >();

+  // Test the 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 defined(__BORLANDC__) || defined(BOOST_MSVC)
+    // We currently don't know how to workaround this bug.
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, int&>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, int*>::value));
+#else
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::reference, const int&>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<Iter1::pointer, const int*>::value));
+#endif
+  }
+  {
+    // Test 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);
@@ -173,7 +238,7 @@ main()

    typedef boost::reverse_iterator_generator<const dummyT*
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-        , const dummyT
+      , dummyT, const dummyT&, const dummyT
 #endif
      >::type const_reverse_iterator;
    
@@ -306,12 +371,12 @@ main()
 #else
    typedef boost::iterator_adaptor<boost::forward_iterator_archetype<dummyT>,
      boost::default_iterator_policies,
-      boost::iterator_traits_generator
-        ::value_type<dummyT>
-        ::reference<const dummyT&>
-        ::pointer<const dummyT*> 
-        ::iterator_category<std::forward_iterator_tag>
-        ::difference_type<std::ptrdiff_t> > adaptor_type;
+      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;
@@ -330,6 +395,41 @@ main()
    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::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 );
+    std::iota( elements.begin(), elements.end(), 0 );
+    
+    index_type indices( index_size );
+    std::iota( indices.begin(), indices.end(), element_range_size - index_size );
+    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;
 }
--- a/iterator_adaptors.htm
+++ b/iterator_adaptors.htm
@@ -26,6 +26,37 @@
    "../../more/generic_programming.html#adaptors">adaptors</a> which apply
    specific useful behaviors to arbitrary base iterators.

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

    <ul>
@@ -91,6 +122,10 @@
      "../../boost/function_output_iterator.hpp">boost/function_output_iterator.hpp</a></tt><br>

       <a href="function_output_iterator.htm">Function Output Iterator Adaptor</a>
+      <li>Header <tt><a href="../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></tt><br>
+       <a href="generator_iterator.htm">Generator Iterator Adaptor</a>
+      <li>Header <tt><a href="../../boost/permutation_iterator.hpp">boost/permutation_iterator.hpp</a></tt><br>
+       <a href="permutation_iterator.htm">Permutation Iterator Adaptor</a>
    </ul>

    <p><b><a href="../../people/dave_abrahams.htm">Dave
@@ -114,7 +149,11 @@
    "filter_iterator.htm">filter_</a></tt> iterator generators and made some
    simplifications to the main <tt><a href=
    "#iterator_adaptor">iterator_adaptor</a></tt> template.<br>
-
+    <b><a href="../../people/jens_maurer.htm">Jens Maurer</a></b>
+    contributed the <a href="generator_iterator.htm">generator iterator</a>
+    adaptor.<br>
+    Toon Knapen contributed the <a href="permutation_iterator.htm">permutation
+    iterator</a> adaptor.<br>

    <h2><a name="iterator_adaptor">Class template</a>
    <tt>iterator_adaptor</tt></h2>
@@ -131,11 +170,11 @@
    <p><tt>iterator_adaptor</tt> is declared like this:
 <pre>
 template &lt;class Base, class Policies, 
-    class ValueOrNamedParams = typename std::iterator_traits&lt;Base&gt;::value_type,
-    class ReferenceOrNamedParams = <i>...(see below)</i>,
-    class PointerOrNamedParams = <i>...(see below)</i>,
-    class CategoryOrNamedParams = typename std::iterator_traits&lt;Base&gt;::iterator_category,
-    class DistanceOrNamedParams = typename std::iterator_traits&lt;Base&gt;::difference_type&gt;
+    class ValueOrNamedParam = typename std::iterator_traits&lt;Base&gt;::value_type,
+    class ReferenceOrNamedParam = <i>...(see below)</i>,
+    class PointerOrNamedParam = <i>...(see below)</i>,
+    class CategoryOrNamedParam = typename std::iterator_traits&lt;Base&gt;::iterator_category,
+    class DistanceOrNamedParam = typename std::iterator_traits&lt;Base&gt;::difference_type&gt;
 struct iterator_adaptor;
 </pre>

@@ -183,7 +222,7 @@ struct iterator_adaptor;
        particular, the result type of <tt>operator*()</tt>.<br>
         <b>Default:</b> If <tt>Value</tt> is supplied, <tt>Value&amp;</tt> is
        used. Otherwise
-        <tt>std::iterator_traits&lt;BaseType&gt;::reference</tt> is used.
+        <tt>std::iterator_traits&lt;BaseType&gt;::reference</tt> is used. <a href="#7">[7]</a>

      <tr>
        <td><tt>Pointer</tt> 
@@ -191,7 +230,7 @@ struct iterator_adaptor;
        <td>The <tt>pointer</tt> type of the resulting iterator, and in
        particular, the result type of <tt>operator-&gt;()</tt>.<br>
         <b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
-        otherwise <tt>std::iterator_traits&lt;BaseType&gt;::pointer</tt>.
+        otherwise <tt>std::iterator_traits&lt;BaseType&gt;::pointer</tt>. <a href="#7">[7]</a>

      <tr>
        <td><tt>Category</tt> 
@@ -208,11 +247,9 @@ struct iterator_adaptor;
        <tt>std::iterator_traits&lt;BaseType&gt;::difference_type</tt> 

      <tr>
-         <td><tt>NamedParams</tt>
+         <td><tt>NamedParam</tt>

-         <td>A list of named template parameters generated using the
-            <a href="#iterator_traits_generator">
-            <tt>iterator_traits_generator</tt></a> class (see below).
+         <td>A named template parameter (see below).
    </table>

    <h3><a name="named_template_parameters">Named Template Parameters</a></h3>
@@ -223,59 +260,32 @@ struct iterator_adaptor;
    template parameter, but use the defaults for the third through
    fifth. As a solution to these problems we provide a mechanism for
    naming the last five template parameters, and providing them in
-    any order through the <tt>iterator_traits_generator</tt> class.
-
+    any order through a set of named template parameters. The following
+    classes are provided for specifying the parameters. Any of these
+    classes can be used for any of the last five template parameters
+    of <tt>iterator_adaptor</tt>.
    <blockquote>
 <pre>
-<a name="iterator_traits_generator">class iterator_traits_generator</a>
-{
-public:
-  template &lt;class Value&gt;
-  struct value_type : public <i>recursive magic</i> { };
-
-  template &lt;class Reference&gt;
-  struct reference : public <i>recursive magic</i> { };
-
-  template &lt;class Pointer&gt;
-  struct pointer : public <i>recursive magic</i> { };
-
-  template &lt;class Distance&gt;
-  struct difference_type : public <i>recursive magic</i> { };
-
-  template &lt;class Category&gt;
-  struct iterator_category : public <i>recursive magic</i> { };
-};
+template &lt;class Value&gt; struct value_type_is;
+template &lt;class Reference&gt; struct reference_is;
+template &lt;class Pointer&gt; struct pointer_is;
+template &lt;class Distance&gt; struct difference_type_is;
+template &lt;class Category&gt; struct iterator_category_is;
 </pre>
    </blockquote>

-    The <tt>iterator_traits_generator</tt> is used to create a list of
-    of template arguments. For example, suppose you want to set the
-    <tt>Reference</tt> and <tt>Category</tt> parameters, and use the
-    defaults for the rest. Then you can use the traits generator as
-    follows:
+    For example, the following adapts <tt>foo_iterator</tt> to create
+    an <a href=
+    "http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+    with <tt>reference</tt> type <tt>foo</tt>, and whose other traits
+    are determined according to the defaults described <a
+    href="#template_parameters">above</a>.

    <blockquote>
 <pre>
-iterator_traits_generator::reference&lt;foo&gt;::category&lt;std::input_iterator_tag&gt;
-</pre>
-    </blockquote>
-
-    This generated type can then be passed into the <tt>iterator_adaptor</tt>
-    class to replace any of the last five parameters. If you use the traits
-    generator in the <i>i</i>th parameter position, then the parameters <i>i</i>
-    through 7 will use the types specified in the generator. For example, the
-    following adapts <tt>foo_iterator</tt> to create an <a href=
-    "http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a> with
-    <tt>reference</tt> type <tt>foo</tt>, and whose other traits are determined
-    according to the defaults described <a href="#template_parameters">above</a>.
-
-    <blockquote>
-<pre>
-iterator_adaptor&lt;foo_iterator, foo_policies,
-    iterator_traits_generator
-    ::reference&lt;foo&gt;
-    ::iterator_category&lt;std::input_iterator_tag&gt;
-&gt;
+typedef iterator_adaptor&lt;foo_iterator, foo_policies,
+  reference_is&lt;foo&gt;, iterator_category_is&lt;std::input_iterator_tag&gt;
+  &gt; MyIterator;
 </pre>
    </blockquote>

@@ -414,40 +424,40 @@ iterator_adaptor&lt;foo_iterator, foo_policies,
 <pre>
 struct <a name="default_iterator_policies">default_iterator_policies</a>
 {
-  template &lt;class BaseType&gt;
-  void initialize(BaseType&amp;)
-    { }
+    // Some of these members were defined static, but Borland got confused
+    // and thought they were non-const. Also, Sun C++ does not like static
+    // function templates.

-  template &lt;class Reference, class BaseType&gt;
-  Reference dereference(type&lt;Reference&gt;, const BaseType&amp; x) const
-    { return *x; }
+    template &lt;class Base&gt;
+    void initialize(Base&amp;)
+        { }

-  template &lt;class BaseType&gt;
-  void increment(BaseType&amp; x)
-    { ++x; }
+    template &lt;class IteratorAdaptor&gt;
+    typename IteratorAdaptor::reference dereference(const IteratorAdaptor&amp; x) const
+        { return *x.base(); }

-  template &lt;class BaseType1, class BaseType2&gt;
-  bool equal(const BaseType1&amp; x, const BaseType2&amp; y) const
-    { return x == y; }
+    template &lt;class IteratorAdaptor&gt;
+    void increment(IteratorAdaptor&amp; x)
+        { ++x.base(); }

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

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

-  template &lt;class Difference, class BaseType1, class BaseType2&gt;
-  Difference distance(type&lt;Difference&gt;, const BaseType1&amp; x, const BaseType2&amp; y) const
-    { return y - x; }
+    template &lt;class IteratorAdaptor1, class IteratorAdaptor2&gt;
+    typename IteratorAdaptor1::difference_type
+    distance(const IteratorAdaptor1&amp; x, const IteratorAdaptor2&amp; y) const
+        { return y.base() - x.base(); }

-  template &lt;class BaseType1, class BaseType2&gt;
-  bool less(const BaseType1&amp; x, const BaseType2&amp; y) const
-    { return x &lt; y; }
+    template &lt;class IteratorAdaptor1, class IteratorAdaptor2&gt;
+    bool equal(const IteratorAdaptor1&amp; x, const IteratorAdaptor2&amp; y) const
+        { return x.base() == y.base(); }
 };
-</pre>
-    </blockquote>
+</pre></blockquote>

    <p>Template member functions are used throughout
    <tt>default_iterator_policies</tt> so that it can be employed with a wide
@@ -480,7 +490,7 @@ struct <a name="default_iterator_policies">default_iterator_policies</a>
         iterator_adaptor(const
        iterator_adaptor&lt;B,Policies,V,R,P,Category,Distance&gt;&amp;)</tt>
        <br><br>
-         This constructor allows for conversion from non-<tt>const</tt> to
+         This constructor allows for conversion from mutable to
        constant adapted iterators. See <a href=
        "#iterator_interactions">below</a> for more details.<br>
         Requires: <tt>B</tt> is convertible to <tt>Base</tt>.
@@ -512,34 +522,31 @@ struct <a name="default_iterator_policies">default_iterator_policies</a>

    <p>To implement a transform iterator we will only change one of the base
    iterator's behaviors, so the <tt>transform_iterator_policies</tt> class can
-    inherit the rest from <tt>default_iterator_policies</tt>. We will define
-    the <tt>dereference()</tt> member function, which is used to implement
+    inherit the rest from <tt>default_iterator_policies</tt>. We will define the
+    <tt>dereference()</tt> member function, which is used to implement
    <tt>operator*()</tt> of the adapted iterator. The implementation will
-    dereference the base iterator and apply the function object. The
-    <tt>type&lt;Reference&gt;</tt> parameter is used to convey the appropriate
-    return type. The complete code for <tt>transform_iterator_policies</tt>
-    is:<br>
+    dereference the base iterator and apply the function object. The complete
+    code for <tt>transform_iterator_policies</tt> is:<br>
    <br>

-
-    <blockquote>
-<pre>
-  template &lt;class AdaptableUnaryFunction&gt;
-  struct transform_iterator_policies : public default_iterator_policies
-  {
+<blockquote><pre>
+template &lt;class AdaptableUnaryFunction&gt;
+struct transform_iterator_policies : public default_iterator_policies
+{
    transform_iterator_policies() { }

    transform_iterator_policies(const AdaptableUnaryFunction&amp; f)
-      : m_f(f) { }
-
-    template &lt;class Reference, class BaseIterator&gt;
-    Reference dereference(type&lt;Reference&gt;, const BaseIterator&amp; i) const
-      { return m_f(*i); }
+        : m_f(f) { }
+    
+    template &lt;class IteratorAdaptor&gt;
+    typename IteratorAdaptor::reference
+    dereference(const IteratorAdaptor&amp; iter) const
+        { return m_f(*iter.base()); }

    AdaptableUnaryFunction m_f;
-  };
-</pre>
-    </blockquote>
+};
+
+</pre></blockquote>

    <p>The next step is to use the <tt>iterator_adaptor</tt> template to
    construct the transform iterator type. The nicest way to package the
@@ -575,7 +582,7 @@ public:

    <p>As a finishing touch, we will create an <a href=
    "../../more/generic_programming.html#object_generator">object generator</a>
-    for the transform iterator. This is a function that makes it more
+    for the transform iterator. Our object generator makes it more
    convenient to create a transform iterator.<br>
    <br>

@@ -814,12 +821,12 @@ bool operator==(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;,
    <tt>reference</tt> types for all <a href=
    "http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterators</a> are
    <tt>const T*</tt> and <tt>const T&amp;</tt>, respectively. Stripping the
-    <tt>const</tt>-ness of <tt>Value</tt> allows you to easily
-    make a <tt>const</tt> iterator adaptor by supplying a <tt>const</tt> type
-    for <tt>Value</tt>, and allowing the defaults for the <tt>Pointer</tt> and
-    <tt>Reference</tt> parameters to take effect. Although compilers that don't
-    support partial specialization won't strip <tt>const</tt> for you, having a
-    <tt>const value_type</tt> is often harmless in practice.
+    <tt>const</tt>-ness of <tt>Value</tt> allows you to easily make a constant
+    iterator by supplying a <tt>const</tt> type for <tt>Value</tt>, and allowing
+    the defaults for the <tt>Pointer</tt> and <tt>Reference</tt> parameters to
+    take effect. Although compilers that don't support partial specialization
+    won't strip <tt>const</tt> for you, having a <tt>const value_type</tt> is
+    often harmless in practice.

    <p><a name="2">[2]</a> If your compiler does not support partial
    specialization and the base iterator is a builtin pointer type, you
@@ -885,6 +892,14 @@ bool operator==(const iterator_adaptor&lt;B1,P,V1,R1,P1,C,D&gt;&amp;,
    *x = i;
 </pre>

+    <p><a name="7">[7]</a>
+    If you are using a compiler that does not have a version of
+    <tt>std::iterator_traits</tt> that works for pointers (i.e., if your
+    compiler does not support partial specialization) then if the
+    <tt>Base</tt> type is a const pointer, then the correct defaults
+    for the <tt>reference</tt> and <tt>pointer</tt> types can not be
+    deduced. You must specify these types explicitly.
+
    <hr>

    <p>Revised 
--- a/iterator_adaptors.pdf
+++ b/iterator_adaptors.pdf
--- a/iterator_adaptors.ppt
+++ b/iterator_adaptors.ppt
--- a/iterators_test.cpp
+++ b/iterators_test.cpp
@@ -75,6 +75,12 @@ protected:

 };  // test_opr_base

+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+//  A definition is required even for integral static constants
+const std::size_t test_opr_base::fruit_length;
+const std::size_t test_opr_base::scratch_length;
+#endif
+
 template <typename T, typename R = T&, typename P = T*>
 class test_opr
    : public test_opr_base
--- a/numeric_traits_test.cpp
+++ b/numeric_traits_test.cpp
@@ -374,7 +374,7 @@ int main()
    test<unsigned int>();
    test<long>();
    test<unsigned long>();
-#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
+#if defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T)
    test<long long>();
    test<unsigned long long>();
 #elif defined(BOOST_MSVC)
--- a/operators.htm
+++ b/operators.htm
@@ -30,7 +30,11 @@ provided by the class.</p>
 	</ul></li>
 	<li><a href="#usage">Usage</a>
 	<ul>
-		<li><a href="#two_arg">Two-Argument Template Forms</a></li>
+		<li><a href="#two_arg">Two-Argument Template Forms</a>
+		<ul>
+			<li><a href="#two_arg_gen">General Considerations</a></li>
+			<li><a href="#mixed_arithmetics">Mixed arithmetics</a></li>
+		</ul></li>
 		<li><a href="#chaining">Base Class Chaining and Object Size</a></li>
 		<li><a href="#explicit_instantiation">Separate, Explicit
 			Instantiation</a></li>
@@ -39,7 +43,10 @@ provided by the class.</p>
 	<li><a href="#example">Example</a></li>
 	<li><a href="#arithmetic">Arithmetic operators</a>
 	<ul>
-		<li><a href="#smpl_oprs">Simple Arithmetic Operators</a></li>
+		<li><a href="#smpl_oprs">Simple Arithmetic Operators</a>
+		<ul>
+			<li><a href="#ordering">Ordering Note</a></li>
+		</ul></li>
 		<li><a href="#grpd_oprs">Grouped Arithmetic Operators</a></li>
 		<li><a href="#ex_oprs">Example Templates</a></li>
 		<li><a href="#a_demo">Arithmetic Operators Demonstration
@@ -49,8 +56,12 @@ provided by the class.</p>
 		Helpers</a>
 	<ul>
 		<li><a href="#dereference">Dereference operators</a></li>
-		<li><a href="#iterator">Iterator Helpers</a></li>
-		<li><a href="#iterator_helpers_notes">Iterator Helper Notes</a></li>
+		<li><a href="#grpd_iter_oprs">Grouped Iterator Operators</a></li>
+		<li><a href="#iterator">Iterator Helpers</a>
+		<ul>
+			<li><a href="#iterator_helpers_notes">Iterator Helper
+				Notes</a></li>
+		</ul></li>
 		<li><a href="#i_demo">Iterator Demonstration and Test
 			Program</a></li>
 	</ul></li>
@@ -151,6 +162,8 @@ domains, <i>i.e.</i> eventually more useful.</p>

 <h3><a name="two_arg">Two-Argument</a> Template Forms</h3>

+<h4><a name="two_arg_gen">General Considerations</a></h4>
+
 <p>The arguments to a binary operator commonly have identical types, but
 it is not unusual to want to define operators which combine different
 types.  For <a href="#example">example</a>, one might want to multiply a
@@ -176,6 +189,46 @@ trailing <code>'1'</code> are provided for symmetry and to enable
 certain applications of the <a href="#chaining">base class chaining</a>
 technique.</p>

+<h4><a name="mixed_arithmetics">Mixed Arithmetics</a></h4>
+
+<p>Another application of the two-argument template forms is for
+mixed arithmetics between a type <code>T</code> and a type <code>U</code>
+that is convertible to <code>T</code>.  In this case there are two ways
+where the two-argument template forms are helpful: one is to provide
+the respective signatures for operator overloading, the second is
+performance.</p>
+
+<p>With respect to the operator overloading assume <i>e.g.</i> that
+<code>U</code> is <code>int</code>, that <code>T</code> is an user-defined
+unlimited integer type, and that <code>double operator-(double, const
+T&amp;)</code> exists.  If one wants to compute <code>int - T</code> and
+does not provide <code>T operator-(int, const T&amp;)</code>, the
+compiler will consider <code>double operator-(double, const T&amp;)</code>
+to be a better match than <code>T operator-(const T&amp;, const
+T&amp;)</code>, which will probably be different from the user's intention.
+To define a complete set of operator signatures, additional 'left' forms
+of the two-argument template forms are provided (<code><a
+href="#subtractable2_left">subtractable2_left&lt;T, U&gt;</a></code>,
+<code><a href="#dividable2_left">dividable2_left&lt;T, U&gt;</a></code>,
+<code><a href="#modable2_left">modable2_left&lt;T, U&gt;</a></code>) that
+define the signatures for non-commutative operators where <code>U</code>
+appears on the left hand side (<code>operator-(const U&amp;, const
+T&amp;)</code>, <code>operator/(const U&amp;, const T&amp;)</code>,
+<code>operator%(const U&amp;, const T&amp;)</code>).</p>
+
+<p>With respect to the performance observe that when one uses the
+single type binary operator for mixed type arithmetics, the type
+<code>U</code> argument has to be converted to type <code>T</code>.  In
+practice, however, there are often more efficient implementations of,
+say <code>T::operator-=(const U&amp;)</code> that avoid unnecessary
+conversions from <code>U</code> to <code>T</code>.  The two-argument
+template forms of the arithmetic operator create additional operator
+interfaces that use these more efficient implementations.  There is, however,
+no performance gain in the 'left' forms: they still need a conversion
+from <code>U</code> to <code>T</code> and have an implementation
+equivalent to the code that would be automatically created by the compiler
+if it considered the single type binary operator to be the best match.</p>
+
 <h3>Base Class <a name="chaining">Chaining</a> and Object Size</h3>

 <p>Every operator class template, except the <a href="#ex_oprs">arithmetic
@@ -419,6 +472,12 @@ for the <a href="#chaining">base class chaining</a> technique.
 		<td><code>t -= u</code>.<br>
 		    Return convertible to <code>T</code>.</td>
 	</tr>
+	<tr>
+		<td><code><a name="subtractable2_left">subtractable2_left&lt;T, U&gt;</a></code></td>
+		<td><code>T operator-(const U&amp;, const T&amp;)</code></td>
+		<td><code>T temp(u); temp -= t</code>.<br>
+		    Return convertible to <code>T</code>.</td>
+	</tr>
 	<tr>
 		<td><code><a name="multipliable1">multipliable&lt;T&gt;</a></code><br>
 		    <code>multipliable1&lt;T&gt;</code></td>
@@ -448,6 +507,12 @@ for the <a href="#chaining">base class chaining</a> technique.
 		<td><code>t /= u</code>.<br>
 		    Return convertible to <code>T</code>.</td>
 	</tr>
+	<tr>
+		<td><code><a name="dividable2_left">dividable2_left&lt;T, U&gt;</a></code></td>
+		<td><code>T operator/(const U&amp;, const T&amp;)</code></td>
+		<td><code>T temp(u); temp /= t</code>.<br>
+		    Return convertible to <code>T</code>.</td>
+	</tr>
 	<tr>
 		<td><code><a name="modable1">modable&lt;T&gt;</a></code><br>
 		    <code>modable1&lt;T&gt;</code></td>
@@ -462,6 +527,12 @@ for the <a href="#chaining">base class chaining</a> technique.
 		<td><code>t %= u</code>.<br>
 		    Return convertible to <code>T</code>.</td>
 	</tr>
+	<tr>
+		<td><code><a name="modable2_left">modable2_left&lt;T, U&gt;</a></code></td>
+		<td><code>T operator%(const U&amp;, const T&amp;)</code></td>
+		<td><code>T temp(u); temp %= t</code>.<br>
+		    Return convertible to <code>T</code>.</td>
+	</tr>
 	<tr>
 		<td><code><a name="orable1">orable&lt;T&gt;</a></code><br>
 		    <code>orable1&lt;T&gt;</code></td>
@@ -588,8 +659,9 @@ for the <a href="#chaining">base class chaining</a> technique.
 	</tr>
 </table>

-<p><strong><a name="ordering">Ordering Note</a></strong><br>
-The <code><a href="#less_than_comparable1">less_than_comparable&lt;T&gt;</a></code>
+<h4><a name="ordering">Ordering</a> Note</h4>
+
+<p>The <code><a href="#less_than_comparable1">less_than_comparable&lt;T&gt;</a></code>
 and <code><a href="#partially_ordered1">partially_ordered&lt;T&gt;</a></code>
 templates provide the same set of operations.  However, the workings of
 <code><a href="#less_than_comparable1">less_than_comparable&lt;T&gt;</a></code>
@@ -771,6 +843,109 @@ optional template parameter <code>B</code>, which is not shown, for the
 			   <li><code><a href="#right_shiftable2">right_shiftable&lt;T, U&gt;</a></code></li>
 		   </ul></td>
 	</tr>
+	<tr>
+		<td><code><a name="ring_operators1">ring_operators&lt;T&gt;</a></code><br>
+		   <code>ring_operators1&lt;T&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#additive1">additive&lt;T&gt;</a></code></li>
+			   <li><code><a href="#multipliable1">multipliable&lt;T&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="ring_operators2">ring_operators&lt;T, U&gt;</a></code><br>
+		   <code>ring_operators2&lt;T, U&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#additive2">additive&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#subtractable2_left">subtractable2_left&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#multipliable2">multipliable&lt;T, U&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="ordered_ring_operators1">ordered_ring_operators&lt;T&gt;</a></code><br>
+		   <code>ordered_ring_operators1&lt;T&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#ring_operators1">ring_operators&lt;T&gt;</a></code></li>
+			   <li><code><a href="#totally_ordered1">totally_ordered&lt;T&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="ordered_ring_operators2">ordered_ring_operators&lt;T, U&gt;</a></code><br>
+		   <code>ordered_ring_operators2&lt;T, U&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#ring_operators2">ring_operators&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#totally_ordered2">totally_ordered&lt;T, U&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="field_operators1">field_operators&lt;T&gt;</a></code><br>
+		   <code>field_operators1&lt;T&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#ring_operators1">ring_operators&lt;T&gt;</a></code></li>
+			   <li><code><a href="#dividable1">dividable&lt;T&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="field_operators2">field_operators&lt;T, U&gt;</a></code><br>
+		   <code>field_operators2&lt;T, U&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#ring_operators2">ring_operators&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#dividable2">dividable&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#dividable2_left">dividable2_left&lt;T, U&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="ordered_field_operators1">ordered_field_operators&lt;T&gt;</a></code><br>
+		   <code>ordered_field_operators1&lt;T&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#field_operators1">field_operators&lt;T&gt;</a></code></li>
+			   <li><code><a href="#totally_ordered1">totally_ordered&lt;T&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="ordered_field_operators2">ordered_field_operators&lt;T, U&gt;</a></code><br>
+		   <code>ordered_field_operators2&lt;T, U&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#field_operators2">field_operators&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#totally_ordered2">totally_ordered&lt;T, U&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="euclidian_ring_operators1">euclidian_ring_operators&lt;T&gt;</a></code><br>
+		   <code>euclidian_ring_operators1&lt;T&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#ring_operators1">ring_operators&lt;T&gt;</a></code></li>
+			   <li><code><a href="#dividable1">dividable&lt;T&gt;</a></code></li>
+			   <li><code><a href="#modable1">modable&lt;T&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="euclidian_ring_operators2">euclidian_ring_operators&lt;T, U&gt;</a></code><br>
+		   <code>euclidian_ring_operators2&lt;T, U&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#ring_operators2">ring_operators&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#dividable2">dividable&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#dividable2_left">dividable2_left&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#modable2">modable&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#modable2_left">modable2_left&lt;T, U&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="ordered_euclidian_ring_operators1">ordered_euclidian_ring_operators&lt;T&gt;</a></code><br>
+		   <code>ordered_euclidian_ring_operators1&lt;T&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#euclidian_ring_operators1">euclidian_ring_operators&lt;T&gt;</a></code></li>
+			   <li><code><a href="#totally_ordered1">totally_ordered&lt;T&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="ordered_euclidian_ring_operators2">ordered_euclidian_ring_operators&lt;T, U&gt;</a></code><br>
+		   <code>ordered_euclidian_ring_operators2&lt;T, U&gt;</code></td>
+		<td><ul>
+			   <li><code><a href="#euclidian_ring_operators2">euclidian_ring_operators&lt;T, U&gt;</a></code></li>
+			   <li><code><a href="#totally_ordered2">totally_ordered&lt;T, U&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+
 </table>

 <h3><a name="ex_oprs">Example</a> Templates</h3>
@@ -888,19 +1063,87 @@ href="#chaining">base class chaining</a>.</p>
 	</tr>
 </table>

-<h3><a name="iterator">Iterator</a> Helpers</h3>
+<h3><a name="grpd_iter_oprs">Grouped Iterator Operators</a></h3>

-<p>There are five separate iterator helper classes, each for a
-different category of iterator.  Here is a summary of the core set of
-operators that the custom iterator must define, and the extra operators
-that are created by the helper classes.  These classes cannot be used for <a
-href="#chaining">base class chaining</a>.  For convenience, the helper
-classes also fill in all of the typedef's required of iterators by the
-C++ standard (<code>iterator_category</code>, <code>value_type</code>,
-<i>etc.</i>).</p>
+<p>There are five iterator operator class templates, each for a different
+category of iterator.  The following table shows the operator groups
+for any category that a custom iterator could define.  These class
+templates have an additional optional template parameter <code>B</code>,
+which is not shown, to support <a href="#chaining">base class chaining</a>.</p>

 <table cellpadding="5" border="1" align="center">
-	<caption>Iterator Helper Template Classes</caption>
+	<caption>Iterator Operator Class Templates</caption>
+	<tr>
+		<td colspan="2"><table align="center" border="1">
+			<caption><em>Key</em></caption>
+			<tr>
+				<td><code>T</code>: operand type</td>
+				<td><code>P</code>: <code>pointer</code> type</td>
+			</tr>
+			<tr>
+				<td><code>D</code>: <code>difference_type</code></td>
+				<td><code>R</code>: <code>reference</code> type</td>
+			</tr>
+			<tr>
+				<td><code>V</code>: <code>value_type</code></td>
+				<td></td>
+			</tr>
+		</table></td>
+	</tr>
+	<tr>
+		<th>Template</th>
+		<th>Component Operator Templates</th>
+	</tr>
+	<tr>
+		<td><code><a name="input_iteratable">input_iteratable&lt;T, P&gt;</a></code></td>
+		<td><ul>
+			   <li><code><a href="#equality_comparable1">equality_comparable&lt;T&gt;</a></code></li>
+			   <li><code><a href="#incrementable">incrementable&lt;T&gt;</a></code></li>
+			   <li><code><a href="#dereferenceable">dereferenceable&lt;T, P&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="output_iteratable">output_iteratable&lt;T&gt;</a></code></td>
+		<td><ul>
+			   <li><code><a href="#incrementable">incrementable&lt;T&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="forward_iteratable">forward_iteratable&lt;T, P&gt;</a></code></td>
+		<td><ul>
+			   <li><code><a href="#input_iteratable">input_iteratable&lt;T, P&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="bidirectional_iteratable">bidirectional_iteratable&lt;T, P&gt;</a></code></td>
+		<td><ul>
+			   <li><code><a href="#forward_iteratable">forward_iteratable&lt;T, P&gt;</a></code></li>
+			   <li><code><a href="#decrementable">decrementable&lt;T&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+	<tr>
+		<td><code><a name="random_access_iteratable">random_access_iteratable&lt;T, P, D, R&gt;</a></code></td>
+		<td><ul>
+			   <li><code><a href="#bidirectional_iteratable">bidirectional_iteratable&lt;T, P&gt;</a></code></li>
+			   <li><code><a href="#totally_ordered1">totally_ordered&lt;T&gt;</a></code></li>
+			   <li><code><a href="#additive2">additive&lt;T, D&gt;</a></code></li>
+			   <li><code><a href="#indexable">indexable&lt;T, D, R&gt;</a></code></li>
+		   </ul></td>
+	</tr>
+</table>
+
+<h3><a name="iterator">Iterator</a> Helpers</h3>
+
+<p>There are also five iterator helper class templates, each corresponding
+to a different iterator category.  These classes cannot be used for <a
+href="#chaining">base class chaining</a>.  The following summaries
+show that these class templates supply both the iterator operators from
+the <a href="#grpd_iter_oprs">iterator operator class templates</a> and
+the iterator typedef's required by the C++ standard (<code>iterator_category</code>,
+<code>value_type</code>, <i>etc.</i>).</p>
+
+<table cellpadding="5" border="1" align="center">
+	<caption>Iterator Helper Class Templates</caption>
 	<tr>
 		<td colspan="2"><table align="center" border="1">
 			<caption><em>Key</em></caption>
@@ -926,16 +1169,14 @@ C++ standard (<code>iterator_category</code>, <code>value_type</code>,
 		<td><code><a name="input_iterator_helper">input_iterator_helper&lt;T, V, D, P, R&gt;</a></code></td>
 		<td>Supports the operations and has the requirements of
 		    <ul>
-			   <li><code><a href="#equality_comparable1">equality_comparable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#incrementable">incrementable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#dereferenceable">dereferenceable&lt;T, P&gt;</a></code></li>
+			   <li><code><a href="#input_iteratable">input_iteratable&lt;T, P&gt;</a></code></li>
 		    </ul></td>
 	</tr>
 	<tr valign="baseline">
 		<td><code><a name="output_iterator_helper">output_iterator_helper&lt;T&gt;</a></code></td>
 		<td>Supports the operations and has the requirements of
 		    <ul>
-			   <li><code><a href="#incrementable">incrementable&lt;T&gt;</a></code></li>
+			   <li><code><a href="#output_iteratable">output_iteratable&lt;T&gt;</a></code></li>
 		    </ul>
        See also [<a href="#1">1</a>], [<a href="#2">2</a>].
        </td>
@@ -944,33 +1185,21 @@ C++ standard (<code>iterator_category</code>, <code>value_type</code>,
 		<td><code><a name="forward_iterator_helper">forward_iterator_helper&lt;T, V, D, P, R&gt;</a></code></td>
 		<td>Supports the operations and has the requirements of
 		    <ul>
-			   <li><code><a href="#equality_comparable1">equality_comparable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#incrementable">incrementable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#dereferenceable">dereferenceable&lt;T, P&gt;</a></code></li>
+			   <li><code><a href="#forward_iteratable">forward_iteratable&lt;T, P&gt;</a></code></li>
 		    </ul></td>
 	</tr>
 	<tr valign="baseline">
 		<td><code><a name="bidirectional_iterator_helper">bidirectional_iterator_helper&lt;T, V, D, P, R&gt;</a></code></td>
 		<td>Supports the operations and has the requirements of
 		    <ul>
-			   <li><code><a href="#equality_comparable1">equality_comparable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#incrementable">incrementable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#decrementable">decrementable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#dereferenceable">dereferenceable&lt;T, P&gt;</a></code></li>
+			   <li><code><a href="#bidirectional_iteratable">bidirectional_iteratable&lt;T, P&gt;</a></code></li>
 		    </ul></td>
 	</tr>
 	<tr valign="baseline">
 		<td><code><a name="random_access_iterator_helper">random_access_iterator_helper&lt;T, V, D, P, R&gt;</a></code></td>
 		<td>Supports the operations and has the requirements of
 		    <ul>
-			   <li><code><a href="#equality_comparable1">equality_comparable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#less_than_comparable1">less_than_comparable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#incrementable">incrementable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#decrementable">decrementable&lt;T&gt;</a></code></li>
-			   <li><code><a href="#dereferenceable">dereferenceable&lt;T, P&gt;</a></code></li>
-			   <li><code><a href="#addable2">addable&lt;T, D&gt;</a></code></li>
-			   <li><code><a href="#subtractable2">subtractable&lt;T, D&gt;</a></code></li>
-			   <li><code><a href="#indexable">indexable&lt;T, D, R&gt;</a></code></li>
+			   <li><code><a href="#random_access_iteratable">random_access_iteratable&lt;T, P, D, R&gt;</a></code></li>
 		   </ul>
 		   To satisfy <cite><a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a></cite>,
 		    <code>x1 - x2</code> with return convertible to <code>D</code>
@@ -978,7 +1207,7 @@ C++ standard (<code>iterator_category</code>, <code>value_type</code>,
 	</tr>
 </table>

-<h3><a name="iterator_helpers_notes">Iterator Helper Notes</a></h3>
+<h4><a name="iterator_helpers_notes">Iterator Helper Notes</a></h4>

 <p><a name="1">[1]</a> Unlike other iterator helpers templates,
 <code>output_iterator_helper</code> takes only one template parameter - the type of
@@ -987,8 +1216,8 @@ restriction, the standard requires <code>difference_type</code> and
 <code>value_type</code> of any output iterator to be 
 <code>void</code> (24.3.1 [lib.iterator.traits]), and
 <code>output_iterator_helper</code> template respects this
-requirement. Also, output iterators in the standard have void <tt>pointer</tt> and
-<tt>reference</tt> types, so the <tt>output_iterator_helper</tt> does the
+requirement. Also, output iterators in the standard have void <code>pointer</code> and
+<code>reference</code> types, so the <code>output_iterator_helper</code> does the
 same.

 <p><a name="2">[2]</a> As self-proxying is the easiest and most common way to 
@@ -1008,13 +1237,13 @@ template&lt;class UnaryFunction&gt;
 struct function_output_iterator
    : boost::output_iterator_helper&lt; function_output_iterator&lt;UnaryFunction&gt; &gt;
 {
-    explicit function_output_iterator(UnaryFunction const& f = UnaryFunction())
+    explicit function_output_iterator(UnaryFunction const&amp; f = UnaryFunction())
        : func(f) {}

    template&lt;typename T&gt;
-    function_output_iterator& operator=(T const& value)
+    function_output_iterator&amp; operator=(T const&amp; value)
    {
-        this->func(value); 
+        this-&gt;func(value); 
        return *this; 
    }

@@ -1093,6 +1322,10 @@ the test results with selected platforms.</p>
 		partial ordering, and arithmetic conversions.  Added the
 		grouped operator classes.  Added helper classes for
 		input and output iterators.
+
+	<dt>Helmut Zeisel
+	<dd>Contributed the 'left' operators and added some
+		grouped operator classes.
 </dl>

 <h2>Note for Users of <a name="old_lib_note">Older Versions</a></h2>
@@ -1142,7 +1375,7 @@ the library remain backward-compatible.</p>

 <hr>

-<p>Revised: 25 Jun 2001</p>
+<p>Revised: 30 Oct 2001</p>

 <p>Copyright &copy; David Abrahams and Beman Dawes 1999-2001. 
 Permission to copy, use, modify, sell and distribute this document is
--- a/operators_test.cpp
+++ b/operators_test.cpp
@@ -8,6 +8,8 @@
 //  See http://www.boost.org for most recent version including documentation.

 //  Revision History
+//  01 Oct 01 Added tests for "left" operators
+//            and new grouped operators. (Helmut Zeisel)
 //  20 May 01 Output progress messages.  Added tests for new operator
 //            templates.  Updated random number generator.  Changed tests to
 //            use Boost Test Tools library.  (Daryle Walker)
@@ -184,6 +186,74 @@ namespace
    template <class T, class U>
    T true_value(Wrapped4<T,U> x) { return x.value(); }
    
+    // U must be convertible to T
+    template <class T, class U>
+    class Wrapped5
+        : boost::ordered_field_operators2<Wrapped5<T, U>, U>
+        , boost::ordered_field_operators1<Wrapped5<T, U> >
+    {
+    public:
+        explicit Wrapped5( T v = T() ) : _value(v) {}
+
+        // Conversion from U to Wrapped5<T,U>
+        Wrapped5(U u) : _value(u) {}
+
+        T value() const { return _value; }
+        bool operator<(const Wrapped5& x) const { return _value < x._value; }
+        bool operator<(U u) const { return _value < u; }
+        bool operator>(U u) const { return _value > u; }
+        bool operator==(const Wrapped5& u) const { return _value == u._value; }
+        bool operator==(U u) const { return _value == u; }
+        Wrapped5& operator/=(const Wrapped5& u) { _value /= u._value; return *this;}
+        Wrapped5& operator/=(U u) { _value /= u; return *this;}
+        Wrapped5& operator*=(const Wrapped5& u) { _value *= u._value; return *this;}
+        Wrapped5& operator*=(U u) { _value *= u; return *this;}
+        Wrapped5& operator-=(const Wrapped5& u) { _value -= u._value; return *this;}
+        Wrapped5& operator-=(U u) { _value -= u; return *this;}
+        Wrapped5& operator+=(const Wrapped5& u) { _value += u._value; return *this;}
+        Wrapped5& operator+=(U u) { _value += u; return *this;}
+
+    private:
+        T _value;
+    };
+    template <class T, class U>
+    T true_value(Wrapped5<T,U> x) { return x.value(); }
+    
+    // U must be convertible to T
+    template <class T, class U>
+    class Wrapped6
+        : boost::ordered_euclidian_ring_operators2<Wrapped6<T, U>, U>
+        , boost::ordered_euclidian_ring_operators1<Wrapped6<T, U> >
+    {
+    public:
+        explicit Wrapped6( T v = T() ) : _value(v) {}
+
+        // Conversion from U to Wrapped6<T,U>
+        Wrapped6(U u) : _value(u) {}
+
+        T value() const { return _value; }
+        bool operator<(const Wrapped6& x) const { return _value < x._value; }
+        bool operator<(U u) const { return _value < u; }
+        bool operator>(U u) const { return _value > u; }
+        bool operator==(const Wrapped6& u) const { return _value == u._value; }
+        bool operator==(U u) const { return _value == u; }
+        Wrapped6& operator%=(const Wrapped6& u) { _value %= u._value; return *this;}
+        Wrapped6& operator%=(U u) { _value %= u; return *this;}
+        Wrapped6& operator/=(const Wrapped6& u) { _value /= u._value; return *this;}
+        Wrapped6& operator/=(U u) { _value /= u; return *this;}
+        Wrapped6& operator*=(const Wrapped6& u) { _value *= u._value; return *this;}
+        Wrapped6& operator*=(U u) { _value *= u; return *this;}
+        Wrapped6& operator-=(const Wrapped6& u) { _value -= u._value; return *this;}
+        Wrapped6& operator-=(U u) { _value -= u; return *this;}
+        Wrapped6& operator+=(const Wrapped6& u) { _value += u._value; return *this;}
+        Wrapped6& operator+=(U u) { _value += u; return *this;}
+
+    private:
+        T _value;
+    };
+    template <class T, class U>
+    T true_value(Wrapped6<T,U> x) { return x.value(); }
+    
    //  MyInt uses only the single template-argument form of all_operators<>
    typedef Wrapped1<int> MyInt;

@@ -193,6 +263,10 @@ namespace

    typedef Wrapped4<short, short> MyShort;

+    typedef Wrapped5<double, int> MyDoubleInt;
+
+    typedef Wrapped6<long, int> MyLongInt;
+
    template <class X1, class Y1, class X2, class Y2>
    void sanity_check(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
@@ -267,6 +341,13 @@ namespace
        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 );
+        BOOST_TEST( (y1 - x1).value() == (y2 - x2) );
+    }
+
    template <class X1, class Y1, class X2, class Y2>
    void test_dividable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
@@ -275,6 +356,14 @@ namespace
            BOOST_TEST( (x1 / y1).value() == (x2 / y2) );
    }
    
+    template <class X1, class Y1, class X2, class Y2>
+    void test_dividable_left(X1 x1, Y1 y1, X2 x2, Y2 y2)
+    {
+        sanity_check( x1, y1, x2, y2 );
+        if ( x2 != 0 )
+            BOOST_TEST( (y1 / x1).value() == (y2 / x2) );
+    }
+
    template <class X1, class Y1, class X2, class Y2>
    void test_modable(X1 x1, Y1 y1, X2 x2, Y2 y2)
    {
@@ -283,6 +372,14 @@ namespace
            BOOST_TEST( (x1 % y1).value() == (x2 % y2) );
    }
    
+    template <class X1, class Y1, class X2, class Y2>
+    void test_modable_left(X1 x1, Y1 y1, X2 x2, Y2 y2)
+    {
+        sanity_check( x1, y1, x2, y2 );
+        if ( x2 != 0 )
+            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)
    {
@@ -374,6 +471,14 @@ namespace
        test_decrementable( x1, x2 );
    }
    
+    template <class X1, class Y1, class X2, class Y2>
+    void test_left(X1 x1, Y1 y1, X2 x2, Y2 y2)
+    {
+        test_subtractable_left( x1, y1, x2, y2 );
+        test_dividable_left( x1, y1, x2, y2 );
+        test_modable_left( x1, y1, x2, y2 );
+     }
+
    template <class Big, class Small>
    struct tester
    {
@@ -388,6 +493,19 @@ namespace
        }
    };

+    template <class Big, class Small>
+    struct tester_left
+    {
+        void operator()(boost::minstd_rand& randomizer) const
+        {
+            Big    b1 = Big( randomizer() );
+            Big    b2 = Big( randomizer() );
+            Small  s = Small( randomizer() );
+            
+            test_left( Wrapped6<Big, Small>(b1), s, b1, s );
+         }
+    };
+
    // added as a regression test. We had a bug which this uncovered.
    struct Point
        : boost::addable<Point
@@ -427,6 +545,13 @@ template Wrapped2<unsigned int, unsigned char>;
 template Wrapped2<unsigned long, unsigned int>;
 template Wrapped2<unsigned long, unsigned char>;
 template Wrapped2<unsigned long, unsigned long>;
+
+template Wrapped6<long, int>;
+template Wrapped6<long, signed char>;
+template Wrapped6<int, signed char>;
+template Wrapped6<unsigned long, unsigned int>;
+template Wrapped6<unsigned long, unsigned char>;
+template Wrapped6<unsigned int, unsigned char>;
 #endif

 #define PRIVATE_EXPR_TEST(e, t)  BOOST_TEST( ((e), (t)) )
@@ -459,6 +584,14 @@ test_main( int , char * [] )
        tester<unsigned long, unsigned long>()(r);
        tester<unsigned int, unsigned int>()(r);
        tester<unsigned int, unsigned char>()(r);
+
+        tester_left<long, int>()(r);
+        tester_left<long, signed char>()(r);
+        tester_left<int, signed char>()(r);
+
+        tester_left<unsigned long, unsigned int>()(r);
+        tester_left<unsigned long, unsigned char>()(r);
+        tester_left<unsigned int, unsigned char>()(r);
    }
    
    cout << "Did random tester loop." << endl;
@@ -653,5 +786,106 @@ test_main( int , char * [] )
    
    cout << "Performed tests on MyShort objects.\n";
    
+    MyDoubleInt di1(1);
+    MyDoubleInt di2(2.);
+    MyDoubleInt half(0.5);
+    MyDoubleInt di;
+    MyDoubleInt tmp;
+
+    BOOST_TEST( di1.value() == 1 );
+    BOOST_TEST( di2.value() == 2 );
+    BOOST_TEST( di2.value() == 2 );
+    BOOST_TEST( di.value() == 0 );
+
+    cout << "Created MyDoubleInt objects.\n";
+
+    PRIVATE_EXPR_TEST( (di = di2), (di.value() == 2) );
+    
+    BOOST_TEST( di2 == di );
+    BOOST_TEST( 2 == di );
+    BOOST_TEST( di == 2 );
+    BOOST_TEST( di1 < di2 );
+    BOOST_TEST( 1 < di2 );
+    BOOST_TEST( di1 <= di2 );
+    BOOST_TEST( 1 <= di2 );
+    BOOST_TEST( di2 > di1 );
+    BOOST_TEST( di2 > 1 );
+    BOOST_TEST( di2 >= di1 );
+    BOOST_TEST( di2 >= 1 );
+    BOOST_TEST( di1 / di2 == half );
+    BOOST_TEST( di1 / 2 == half );
+    BOOST_TEST( 1 / di2 == half );
+    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=2) == half) );
+    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp/=di2) == half) );
+    BOOST_TEST( di1 * di2 == di2 );
+    BOOST_TEST( di1 * 2 == di2 );
+    BOOST_TEST( 1 * di2 == di2 );
+    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=2) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp*=di2) == di2) );
+    BOOST_TEST( di2 - di1 == di1 );
+    BOOST_TEST( di2 - 1 == di1 );
+    BOOST_TEST( 2 - di1 == di1 );
+    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=1) == di1) );
+    PRIVATE_EXPR_TEST( (tmp=di2), ((tmp-=di1) == di1) );
+    BOOST_TEST( di1 + di1 == di2 );
+    BOOST_TEST( di1 + 1 == di2 );
+    BOOST_TEST( 1 + di1 == di2 );
+    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=1) == di2) );
+    PRIVATE_EXPR_TEST( (tmp=di1), ((tmp+=di1) == di2) );
+
+    cout << "Performed tests on MyDoubleInt objects.\n";
+
+    MyLongInt li1(1);
+    MyLongInt li2(2);
+    MyLongInt li;
+    MyLongInt tmp2;
+
+    BOOST_TEST( li1.value() == 1 );
+    BOOST_TEST( li2.value() == 2 );
+    BOOST_TEST( li.value() == 0 );
+
+    cout << "Created MyLongInt objects.\n";
+
+    PRIVATE_EXPR_TEST( (li = li2), (li.value() == 2) );
+    
+    BOOST_TEST( li2 == li );
+    BOOST_TEST( 2 == li );
+    BOOST_TEST( li == 2 );
+    BOOST_TEST( li1 < li2 );
+    BOOST_TEST( 1 < li2 );
+    BOOST_TEST( li1 <= li2 );
+    BOOST_TEST( 1 <= li2 );
+    BOOST_TEST( li2 > li1 );
+    BOOST_TEST( li2 > 1 );
+    BOOST_TEST( li2 >= li1 );
+    BOOST_TEST( li2 >= 1 );
+    BOOST_TEST( li1 % li2 == li1 );
+    BOOST_TEST( li1 % 2 == li1 );
+    BOOST_TEST( 1 % li2 == li1 );
+    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=2) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2%=li2) == li1) );
+    BOOST_TEST( li1 / li2 == 0 );
+    BOOST_TEST( li1 / 2 == 0 );
+    BOOST_TEST( 1 / li2 == 0 );
+    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=2) == 0) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2/=li2) == 0) );
+    BOOST_TEST( li1 * li2 == li2 );
+    BOOST_TEST( li1 * 2 == li2 );
+    BOOST_TEST( 1 * li2 == li2 );
+    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=2) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2*=li2) == li2) );
+    BOOST_TEST( li2 - li1 == li1 );
+    BOOST_TEST( li2 - 1 == li1 );
+    BOOST_TEST( 2 - li1 == li1 );
+    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=1) == li1) );
+    PRIVATE_EXPR_TEST( (tmp2=li2), ((tmp2-=li1) == li1) );
+    BOOST_TEST( li1 + li1 == li2 );
+    BOOST_TEST( li1 + 1 == li2 );
+    BOOST_TEST( 1 + li1 == li2 );
+    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=1) == li2) );
+    PRIVATE_EXPR_TEST( (tmp2=li1), ((tmp2+=li1) == li2) );
+
+    cout << "Performed tests on MyLongInt objects.\n";
+
    return boost::exit_success;
 }
--- a/permutation_iterator.htm
+++ b/permutation_iterator.htm
@@ -0,0 +1,159 @@
+<!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 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></td>.
+The <code>IndexIterator::value_type</code> must be convertible to the 
+<code>ElementIterator::difference_type</code>.
+</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 OrderIterator. Thus for instance, although the permutation
+iterator provides <code>operator+=(distance)</code>, this operation will take linear time
+in case the OrderIterator 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; order);
+</pre>
+</blockquote>
+
+<h2>Example</h2>
+<blockquote>
+<pre>
+  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 );
+  std::iota( elements.begin(), elements.end(), 0 );
+
+  index_type indices( index_size );
+  std::iota( indices.begin(), indices.end(), element_range_size - index_size );
+  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.setf( std::ios_base::left );
+  std::cout << std::setw( 50 ) << "The original range is : ";
+  std::copy( elements.begin(), elements.end(), std::ostream_iterator< int >( std::cout, " " ) );
+  std::cout << "\n";
+
+  std::cout << std::setw( 50 ) << "The reindexing scheme is : ";
+  std::copy( indices.begin(), indices.end(), std::ostream_iterator< int >( std::cout, " " ) );
+  std::cout << "\n";
+
+  std::cout << std::setw( 50 ) << "The permutated range is : ";
+  std::copy( begin, end, std::ostream_iterator< int >( std::cout, " " ) );
+  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>
--- a/tie_example.cpp
+++ b/tie_example.cpp
@@ -14,7 +14,7 @@
 //
 // 3 successfully inserted.
 // 9 was already in the set.
-// There were 2 occurances of 4.
+// There were 2 occurrences of 4.

 #include <set>
 #include <algorithm>
@@ -55,7 +55,7 @@ main(int, char*[])

    boost::tie(i,end) = std::equal_range(vals, vals + 6, 4);
    std::cout << "There were " << std::distance(i,end)
-	      << " occurances of " << *i << "." << std::endl;
+	      << " occurrences of " << *i << "." << std::endl;
    // Footnote: of course one would normally just use std::count()
    // to get this information, but that would spoil the example :)
  }
Author	SHA1	Message	Date
nobody	a633f6bc13	This commit was manufactured by cvs2svn to create tag 'Version_1_26_0'. [SVN r11842]	2001-11-30 18:24:42 +00:00
Beman Dawes	8619c9b5c3	fix gcc looping (from Dave Abrahams) [SVN r11839]	2001-11-30 17:55:39 +00:00
Toon Knapen	e4d5684f6b	added test for permutation_iterator [SVN r11825]	2001-11-30 11:10:07 +00:00
Toon Knapen	3d69cf95da	added documentation for the permutation_iterator_adaptor and linked to it from the iterator_adaptors documentation. [SVN r11824]	2001-11-30 10:40:03 +00:00
Dave Abrahams	18944572b7	committing Daryle and Helmut's changes [SVN r11813]	2001-11-29 21:22:52 +00:00
Jens Maurer	3e9d0f80c2	add generator iterator adaptor [SVN r11736]	2001-11-19 22:11:51 +00:00
Jens Maurer	a2c4d1990a	add boost::generator_iterator_policies and convenience classes [SVN r11725]	2001-11-18 17:56:43 +00:00
Jens Maurer	404261c6ee	add definition for integral constants initialized in-class [SVN r11723]	2001-11-18 17:32:19 +00:00
Peter Dimov	87abc59612	#undef BOOST_REF_CONST added [SVN r11674]	2001-11-14 14:40:29 +00:00
Peter Dimov	cb98ddf7db	Fixed a bug w/ adaptable function objects + nested binds, made ref<> return const [SVN r11670]	2001-11-13 13:56:05 +00:00
Peter Dimov	7d2e6c9025	__stdcall support added. [SVN r11649]	2001-11-10 19:18:58 +00:00
Dave Abrahams	75eaa14a18	Removed defunct boost::tied (thanks, Daryle Walker) [SVN r11622]	2001-11-07 10:35:12 +00:00
Jeremy Siek	082d6e3b32	* empty log message * [SVN r11614]	2001-11-06 16:09:14 +00:00
Jeremy Siek	35b3770b6f	* empty log message * [SVN r11613]	2001-11-06 16:05:25 +00:00
Jeremy Siek	5b9d20c7e2	* empty log message * [SVN r11611]	2001-11-06 15:52:56 +00:00
Jeremy Siek	5bbed2372e	* empty log message * [SVN r11602]	2001-11-05 21:03:59 +00:00
Jens Maurer	a9d407d239	update SunCC to 6.u2 (C++ 5.3) [SVN r11601]	2001-11-05 21:00:53 +00:00
Jeremy Siek	3ca4a33a65	updated for named parameters [SVN r11566]	2001-11-04 16:21:51 +00:00
Jeremy Siek	95197f427c	remoeved #if 0 [SVN r11565]	2001-11-04 16:18:10 +00:00
Jeremy Siek	84cdfb032c	commit these changes [SVN r11563]	2001-11-04 04:37:14 +00:00
Dave Abrahams	ec2ceb9c96	no message [SVN r11508]	2001-11-01 17:22:39 +00:00
John Maddock	6286c893fd	Minor regression fixes for Borland and Sunpro tests. [SVN r11470]	2001-10-30 11:41:35 +00:00
Jeremy Siek	354aef0e8c	changed named parameters doc to match new stuff [SVN r11417]	2001-10-22 17:04:23 +00:00
John Maddock	139e33c36d	Updated preprocessor logic to use BOOST_HAS_LONG_LONG [SVN r11399]	2001-10-18 11:33:52 +00:00
Dave Abrahams	e01de59cdd	Made these actually compile [SVN r11378]	2001-10-12 22:22:42 +00:00
Darin Adler	686f822dea	Fix spelling error: "occurances" -> "occurrences". [SVN r11376]	2001-10-11 17:26:04 +00:00
John Maddock	9961d5c9af	Last fix had broken preprocessor logic, now fixed. [SVN r11373]	2001-10-11 12:04:00 +00:00
John Maddock	628be0d125	Fixes for Sunpro C++ 5.3 (code now works!) [SVN r11368]	2001-10-09 11:24:56 +00:00
John Maddock	633e45f61a	Fixed test to work with sunpro 5.3 (omits array specialisation tests) [SVN r11359]	2001-10-08 11:35:05 +00:00
John Maddock	2f357c3805	Partial fixes for sunpro 5.3 - doesn't actually work yet though [SVN r11355]	2001-10-08 11:31:29 +00:00
John Maddock	cda0894d0d	Fix for sunpro 5.3 (array specialisations don't work) [SVN r11354]	2001-10-08 11:30:53 +00:00