From a17934adb53fb525dff4178917c4e73bd74ef9ff Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 22 Oct 2002 22:10:49 +0000
Subject: [PATCH] iterator_adaptor portability and fleshing-out

[SVN r600]
---
 example/Jamfile                              |  1 +
 example/reverse_iterator.cpp                 |  9 ++-
 include/boost/iterator/iterator_adaptors.hpp | 78 +++++++++++---------
 3 files changed, 49 insertions(+), 39 deletions(-)
 create mode 100644 example/Jamfile

diff --git a/example/Jamfile b/example/Jamfile
new file mode 100644
index 0000000..921ff30
--- /dev/null
+++ b/example/Jamfile
@@ -0,0 +1 @@
+unit-test ia1 : reverse_iterator.cpp : <sysinclude>../../.. <sysinclude>$(BOOST) ;
\ No newline at end of file
diff --git a/example/reverse_iterator.cpp b/example/reverse_iterator.cpp
index 73c7c64..1aec7e3 100644
--- a/example/reverse_iterator.cpp
+++ b/example/reverse_iterator.cpp
@@ -1,8 +1,8 @@
+#include <boost/iterator/iterator_adaptors.hpp>
+#include <boost/cstdlib.hpp>
 #include <iostream>
 #include <iterator>
-#include "boost/iterator/iterator_adaptors.hpp"
-#include "boost/cstdlib.hpp"
-
+#include <algorithm>
 
 int main()
 {
@@ -10,5 +10,6 @@ int main()
   boost::reverse_iterator<int*, int, int&, int*, std::random_access_iterator_tag, std::ptrdiff_t>
     first(x + 4), last(x);
   std::copy(first, last, std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;  
+  std::cout << std::endl;
+  return 0;
 }
diff --git a/include/boost/iterator/iterator_adaptors.hpp b/include/boost/iterator/iterator_adaptors.hpp
index 609e985..192b4d4 100644
--- a/include/boost/iterator/iterator_adaptors.hpp
+++ b/include/boost/iterator/iterator_adaptors.hpp
@@ -1,61 +1,62 @@
 #ifndef BOOST_ITERATOR_ADAPTORS_HPP
 #define BOOST_ITERATOR_ADAPTORS_HPP
 
-#include "boost/utility.hpp" // for prior
+#include <boost/utility.hpp> // for prior
+#include <boost/iterator.hpp>
 
 namespace boost {
 
-template <class Derived>
-struct iterator_comparisons { };
+template <class Derived, class Base>
+struct iterator_comparisons : Base { };
 
-template <class D1, class D2>
-inline bool operator==(const iterator_comparisons<D1>& xb,
-                       const iterator_comparisons<D2>& yb)
+template <class D1, class D2, class B1, class B2>
+inline bool operator==(const iterator_comparisons<D1,B1>& xb,
+                       const iterator_comparisons<D2,B2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
     return x.equal(y);
 }
 
-template <class D1, class D2>
-inline bool operator!=(const iterator_comparisons<D1>& xb,
-                       const iterator_comparisons<D2>& yb)
+template <class D1, class D2, class B1, class B2>
+inline bool operator!=(const iterator_comparisons<D1,B1>& xb,
+                       const iterator_comparisons<D2,B2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
     return !x.equal(y);
 }
 
-template <class D1, class D2>
-inline bool operator<(const iterator_comparisons<D1>& xb,
-                      const iterator_comparisons<D2>& yb)
+template <class D1, class D2, class B1, class B2>
+inline bool operator<(const iterator_comparisons<D1,B1>& xb,
+                      const iterator_comparisons<D2,B2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
     return y.distance(x) < 0;
 }
 
-template <class D1, class D2>
-inline bool operator>(const iterator_comparisons<D1>& xb,
-                      const iterator_comparisons<D2>& yb)
+template <class D1, class D2, class B1, class B2>
+inline bool operator>(const iterator_comparisons<D1,B1>& xb,
+                      const iterator_comparisons<D2,B2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
     return y.distance(x) > 0;
 }
 
-template <class D1, class D2>
-inline bool operator>=(const iterator_comparisons<D1>& xb,
-                       const iterator_comparisons<D2>& yb)
+template <class D1, class D2, class B1, class B2>
+inline bool operator>=(const iterator_comparisons<D1,B1>& xb,
+                       const iterator_comparisons<D2,B2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
     return y.distance(x) >= 0;
 }
 
-template <class D1, class D2>
-inline bool operator<=(const iterator_comparisons<D1>& xb,
-                       const iterator_comparisons<D2>& yb)
+template <class D1, class D2, class B1, class B2>
+inline bool operator<=(const iterator_comparisons<D1,B1>& xb,
+                       const iterator_comparisons<D2,B2>& yb)
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
@@ -63,24 +64,24 @@ inline bool operator<=(const iterator_comparisons<D1>& xb,
 }
 
 
-template <class Derived, class D>
-struct iterator_arith : public iterator_comparisons<Derived> { };
+template <class Derived, class D, class Base>
+struct iterator_arith : public iterator_comparisons<Derived,Base> { };
 
-template <class Derived, class D>
-D operator+(iterator_arith<Derived, D> i, D n) { return i += n; }
+template <class Derived, class D, class Base>
+D operator+(iterator_arith<Derived, D, Base> i, D n) { return i += n; }
 
-template <class Derived, class D>
-D operator+(D n, iterator_arith<Derived, D> i) { return i += n; }
+template <class Derived, class D, class Base>
+D operator+(D n, iterator_arith<Derived, D, Base> i) { return i += n; }
 
-template <class Derived, class D>
-D operator-(const iterator_arith<Derived, D>& i,
-            const iterator_arith<Derived, D>& j)
+template <class Derived, class D, class Base>
+D operator-(const iterator_arith<Derived, D, Base>& i,
+            const iterator_arith<Derived, D, Base>& j)
   { return static_cast<const Derived&>(j).distance(static_cast<const Derived&>(i)); }
 
 
 template <class Derived, 
   class V, class R, class P, class C, class D>
-class iterator_adaptor : public iterator_arith<Derived, D>
+class iterator_adaptor : public iterator_arith<Derived, D, iterator<C,V,D,P,R> >
 {
 public:
   typedef V value_type;
@@ -108,6 +109,11 @@ public:
     { derived().advance(-n); return derived(); }
   Derived operator-(difference_type x) const
     { Derived result(derived()); return result -= x; }
+
+  template <class Derived2, class V2, class R2, class P2>
+  bool equal(iterator_adaptor<Derived2,V2,R2,P2,C,D> const& x) const
+    { return this->derived().base() == x.derived().base(); }
+    
 private:
   Derived& derived() { return static_cast<Derived&>(*this); }
   const Derived& derived() const { return static_cast<const Derived&>(*this); }
@@ -120,20 +126,22 @@ template <class Base,
 class reverse_iterator : public iterator_adaptor<reverse_iterator<Base, V, R, P, C, D>, V, R, P, C, D>
 {
   typedef iterator_adaptor<reverse_iterator<Base, V, R, P, C, D>, V, R, P, C, D> super;
-  friend class super;
+//  friend class super;
   // hmm, I don't like the next two lines
-  template <class Der> friend struct iterator_comparisons;
-  template <class Der, class Dist> friend struct iterator_arith;
+//  template <class Der> friend struct iterator_comparisons;
+//  template <class Der, class Dist> friend struct iterator_arith;
 public:
   reverse_iterator(const Base& x) : m_base(x) { }
 
   reverse_iterator() { }
 
+  Base const& base() const { return m_base; }
+    
   template <class B2, class V2, class R2, class P2, class C2, class D2>
   reverse_iterator(const reverse_iterator<B2,V2,R2,P2,C2,D2>& y)
     : m_base(y.m_base) { }
   //private:  hmm, the above friend decls aren't doing the job.
-  typename super::reference dereference() const { *boost::prior(m_base); }
+  typename super::reference dereference() const { return *boost::prior(m_base); }
   void increment() { --m_base; }
   void decrement() { ++m_base; }
   void advance(typename super::difference_type n)