This commit was manufactured by cvs2svn to create tag

'Version_1_19_0'.

[SVN r8447]

include/boost/pending/detail/int_iterator.hpp

@@ -40,7 +40,7 @@ public:
   inline self& operator++() { ++_i; return *this; }
   inline self operator++(int) { self t = *this; ++_i; return t; }
   inline self& operator+=(IntT n) { _i += n; return *this; }
-  inline self operator+(IntT n) { self t = *this; t._i += n; return t; }
+  inline self operator+(IntT n) { self t = *this; t += n; return t; }
   inline self& operator--() { --_i; return *this; }
   inline self operator--(int) { self t = *this; --_i; return t; }
   inline self& operator-=(IntT n) { _i -= n; return *this; }
@@ -50,10 +50,17 @@ public:
   // need to look into this... for now implementing everything here -JGS
   inline bool operator!=(const self& x) const { return _i != x._i; }
   inline bool operator<(const self& x) const { return _i < x._i; }
+  inline bool operator<=(const self& x) const { return _i <= x._i; }
+  inline bool operator>(const self& x) const { return _i > x._i; }
+  inline bool operator>=(const self& x) const { return _i >= x._i; }
 protected:
   IntT _i;
 };
 
+template <class IntT>
+inline int_iterator<IntT>
+operator+(IntT n, int_iterator<IntT> t) { t += n; return t; }
+
 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
 } /* namespace boost */
 #endif

include/boost/pending/integer_range.hpp

@@ -13,10 +13,17 @@
 #ifndef BOOST_INTEGER_RANGE_HPP_
 #define BOOST_INTEGER_RANGE_HPP_
 
-#ifdef BOOST_MSVC
+#include <boost/config.hpp>
-#include <boost/pending/detail/int_iterator.hpp>
+
-#else
+#if 1
+// Still evaluating whether VC++ can handle this.
+#define BOOST_USE_ITERATOR_ADAPTORS
+#endif
+
+#ifdef BOOST_USE_ITERATOR_ADAPTORS
 #include <boost/pending/iterator_adaptors.hpp>
+#else
+#include <boost/pending/detail/int_iterator.hpp>
 #endif
 
 namespace boost {
@@ -24,29 +31,34 @@ namespace boost {
 //=============================================================================
 // Counting Iterator and Integer Range Class
 
+#ifdef BOOST_USE_ITERATOR_ADAPTORS
+template <class IntegerType>
 struct counting_iterator_policies : public default_iterator_policies
 {
-    template <class IntegerType>
+    const IntegerType&
-    IntegerType dereference(type<IntegerType>, const IntegerType& i) const
+    dereference(type<const IntegerType&>, const IntegerType& i) const
         { return i; }
 };
 template <class IntegerType>
 struct counting_iterator_traits {
     typedef IntegerType value_type;
-    typedef IntegerType reference;
+    typedef const IntegerType& reference;
     typedef value_type* pointer;
     typedef std::ptrdiff_t difference_type;
     typedef std::random_access_iterator_tag iterator_category;
 };
+#endif
 
 template <class IntegerType>
 struct integer_range {
-#ifdef BOOST_MSVC
+#ifdef BOOST_USE_ITERATOR_ADAPTORS
-    typedef int_iterator<IntegerType> iterator;
+    typedef iterator_adaptor<IntegerType,
+      counting_iterator_policies<IntegerType>,
+      counting_iterator_traits<IntegerType> > iterator;
 #else
-    typedef iterator_adaptor<IntegerType, counting_iterator_policies,
+    typedef int_iterator<IntegerType> iterator;
-      counting_iterator_traits<IntegerType>, IntegerType> iterator;
 #endif
+
     typedef iterator const_iterator;
     typedef IntegerType value_type;
     typedef std::ptrdiff_t difference_type;
@@ -71,6 +83,17 @@ protected:
     IntegerType m_start, m_finish;
 };
 
+template <class IntegerType>
+inline integer_range<IntegerType>
+make_integer_range(IntegerType first, IntegerType last)
+{
+  return integer_range<IntegerType>(first, last);
+}
+
 } // namespace boost
 
+#ifdef BOOST_USE_ITERATOR_ADAPTORS
+#undef BOOST_USE_ITERATOR_ADAPTORS
+#endif
+
 #endif // BOOST_INTEGER_RANGE_HPP_

include/boost/pending/iterator_adaptors.hpp

@@ -13,15 +13,14 @@
 #ifndef BOOST_ITERATOR_ADAPTOR_DWA053000_HPP_
 #define BOOST_ITERATOR_ADAPTOR_DWA053000_HPP_
 
-#include <iterator>
+#include <boost/iterator.hpp>
 #include <boost/utility.hpp>
-#include <boost/operators.hpp>
 #include <boost/compressed_pair.hpp>
 
 // I was having some problems with VC6. I couldn't tell whether our hack for
 // stock GCC was causing problems so I needed an easy way to turn it on and
-// off. Now we can test the hack with various compilers and still have an "out"
+// off. Now we can test the hack with various compilers and still have an 
-// if it doesn't work. -dwa 7/31/00
+// "out" if it doesn't work. -dwa 7/31/00
 #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 && !defined(__STL_USE_NAMESPACES)
 # define BOOST_RELOPS_AMBIGUITY_BUG 1
 #endif
@@ -32,37 +31,42 @@ namespace boost {
 template <class T>
 struct type {};
 
-//=============================================================================
+//============================================================================
 // Default policies for iterator adaptors. You can use this as a base
 // class if you want to customize particular policies.
 struct default_iterator_policies
 {
+    // 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 <class Reference, class Iterator>
-    static Reference dereference(type<Reference>, const Iterator& x)
+    Reference dereference(type<Reference>, const Iterator& x) const
         { return *x; }
 
     template <class Iterator>
-    static void increment(Iterator& x)
+    void increment(Iterator& x)
         { ++x; }
 
     template <class Iterator>
-    static void decrement(Iterator& x)
+    void decrement(Iterator& x)
         { --x; }
 
     template <class Iterator, class DifferenceType>
-    static void advance(Iterator& x, DifferenceType n)
+    void advance(Iterator& x, DifferenceType n)
         { x += n; }
 
     template <class Difference, class Iterator1, class Iterator2>
-    static Difference distance(type<Difference>, const Iterator1& x, const Iterator2& y)
+    Difference distance(type<Difference>, const Iterator1& x,
+                        const Iterator2& y) const
         { return y - x; }
 
     template <class Iterator1, class Iterator2>
-    static bool equal(const Iterator1& x, const Iterator2& y)
+    bool equal(const Iterator1& x, const Iterator2& y) const
         { return x == y; }
 
     template <class Iterator1, class Iterator2>
-    static bool less(const Iterator1& x, const Iterator2& y)
+    bool less(const Iterator1& x, const Iterator2& y) const
         { return x < y; }
 };
 
@@ -128,7 +132,7 @@ inline bool operator<=(const iterator_comparisons<D1,Base1>& xb,
 }
 #endif
 
-//=============================================================================
+//============================================================================
 // iterator_adaptor - A generalized adaptor around an existing
 //   iterator, which is itself an iterator
 //
@@ -140,22 +144,17 @@ inline bool operator<=(const iterator_comparisons<D1,Base1>& xb,
 //   Traits - a class satisfying the same requirements as a specialization of
 //      std::iterator_traits for the resulting iterator.
 //
-//   NonconstIterator - the corresponding non-const iterator type for
-//      Iterator, if any. You don't need to supply this if you are not make a
-//      const/non-const iterator pair.
-//
 template <class Iterator, class Policies, 
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
-          class Traits,
+          class Traits
 #else
-          class Traits = std::iterator_traits<Iterator>,
+          class Traits = std::iterator_traits<Iterator>
 #endif
-          class NonconstIterator = Iterator
          >
 struct iterator_adaptor :
 #ifdef BOOST_RELOPS_AMBIGUITY_BUG
     iterator_comparisons<
-          iterator_adaptor<Iterator,Policies,Traits,NonconstIterator>,
+          iterator_adaptor<Iterator,Policies,Traits>,
 #endif
           boost::iterator<typename Traits::iterator_category, 
               typename Traits::value_type, typename Traits::difference_type,
@@ -164,45 +163,26 @@ struct iterator_adaptor :
 >
 #endif
 {
-    typedef iterator_adaptor<Iterator, Policies, Traits,NonconstIterator> Self;
+    typedef iterator_adaptor<Iterator, Policies, Traits> Self;
 public:
     typedef typename Traits::difference_type difference_type;
     typedef typename Traits::value_type value_type;
     typedef typename Traits::pointer pointer;
     typedef typename Traits::reference reference;
     typedef typename Traits::iterator_category iterator_category;
+    typedef Iterator iterator_type;
 
     iterator_adaptor() { }
 
     iterator_adaptor(const Iterator& iter, const Policies& p = Policies())
         : m_iter_p(iter, p) {}
 
-#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
+    template <class OtherIter, class OtherTraits>
-    template <class MutableIterator, class OtherTraits>
+    iterator_adaptor (const iterator_adaptor<OtherIter, Policies,
-    iterator_adaptor(const iterator_adaptor<MutableIterator, Policies, OtherTraits, NonconstIterator>& rhs)
+            OtherTraits>& src)
-        : m_iter_p(rhs.iter(), rhs.policies()) {}
+            : m_iter_p(src.iter(), src.policies()) {
-    
-    template <class MutableIterator, class OtherTraits>
-    Self& operator=(const iterator_adaptor<MutableIterator, Policies, OtherTraits, NonconstIterator>& rhs)
-    { 
-      iter() = rhs.iter(); 
-      policies() = rhs.policies();
-      return *this; 
     }
-#else
+
-    template <class OtherTraits>
-    iterator_adaptor(const iterator_adaptor<NonconstIterator, Policies, OtherTraits, NonconstIterator>& rhs)
-        : m_iter_p(rhs.iter(), rhs.policies()) {}
-    
-    template <class OtherTraits>
-    Self& operator=(const iterator_adaptor<NonconstIterator, Policies, OtherTraits, NonconstIterator>& rhs)
-    { 
-      iter() = rhs.iter(); 
-      policies() = rhs.policies();
-      return *this; 
-    }
-#endif
-    
     reference operator*() const {
         return policies().dereference(type<reference>(), iter());
     }
@@ -223,29 +203,49 @@ public:
         { return *(*this + n); }
     
     Self& operator++() {
+#ifdef __MWERKS__
+        // Odd bug, MWERKS couldn't  deduce the type for the member template
+        // Workaround by explicitly specifying the type.
+        policies().increment<Iterator>(iter());
+#else
         policies().increment(iter());
+#endif
         return *this;
     }
 
     Self operator++(int) { Self tmp(*this); ++*this; return tmp; }
     
     Self& operator--() {
+#ifdef __MWERKS__
+        policies().decrement<Iterator>(iter());
+#else
         policies().decrement(iter());
+#endif
         return *this;
     }
     
     Self operator--(int) { Self tmp(*this); --*this; return tmp; }
 
     Self& operator+=(difference_type n) {
+#ifdef __MWERKS__
+        policies().advance<Iterator>(iter(), n);
+#else
         policies().advance(iter(), n);
+#endif
         return *this;
     }
   
     Self& operator-=(difference_type n) {
+#ifdef __MWERKS__
+        policies().advance<Iterator>(iter(), -n);
+#else
         policies().advance(iter(), -n);
+#endif
         return *this;
     }
 
+    iterator_type base() const { return m_iter_p.first(); }
+
 private:
     typedef Policies policies_type;
     compressed_pair<Iterator,Policies> m_iter_p;
@@ -256,73 +256,73 @@ public: // too many compilers have trouble when these are private.
     const Iterator& iter() const { return m_iter_p.first(); }
 };
 
-template <class Iterator, class Policies, class Traits, class NonconstIterator>
+template <class Iterator, class Policies, class Traits>
-iterator_adaptor<Iterator,Policies,Traits,NonconstIterator>
+iterator_adaptor<Iterator,Policies,Traits>
-operator-(iterator_adaptor<Iterator,Policies,Traits,NonconstIterator> p, const typename Traits::difference_type x)
+operator-(iterator_adaptor<Iterator,Policies,Traits> p, const typename Traits::difference_type x)
 {
     return p -= x;
 }
 
-template <class Iterator, class Policies, class Traits, class NonconstIterator>
+template <class Iterator, class Policies, class Traits>
-iterator_adaptor<Iterator,Policies,Traits,NonconstIterator>
+iterator_adaptor<Iterator,Policies,Traits>
-operator+(iterator_adaptor<Iterator,Policies,Traits,NonconstIterator> p, const typename Traits::difference_type x)
+operator+(iterator_adaptor<Iterator,Policies,Traits> p, typename Traits::difference_type x)
 {
     return p += x;
 }
 
-template <class Iterator, class Policies, class Traits, class NonconstIterator>
+template <class Iterator, class Policies, class Traits>
-iterator_adaptor<Iterator,Policies,Traits,NonconstIterator>
+iterator_adaptor<Iterator,Policies,Traits>
-operator+(const typename Traits::difference_type x, iterator_adaptor<Iterator,Policies,Traits,NonconstIterator> p)
+operator+(typename Traits::difference_type x, iterator_adaptor<Iterator,Policies,Traits> p)
 {
     return p += x;
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
 typename Traits1::difference_type operator-(
-    const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x,
+    const iterator_adaptor<Iterator1,Policies,Traits1>& x,
-    const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y )
+    const iterator_adaptor<Iterator2,Policies,Traits2>& y )
 {
     typedef typename Traits1::difference_type difference_type;
     return x.policies().distance(type<difference_type>(), y.iter(), x.iter());
 }
 
 #ifndef BOOST_RELOPS_AMBIGUITY_BUG
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
 inline bool 
-operator==(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x, const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
+operator==(const iterator_adaptor<Iterator1,Policies,Traits1>& x, const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
     return x.policies().equal(x.iter(), y.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
 inline bool 
-operator<(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x, const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
+operator<(const iterator_adaptor<Iterator1,Policies,Traits1>& x, const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
     return x.policies().less(x.iter(), y.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
 inline bool 
-operator>(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x,
+operator>(const iterator_adaptor<Iterator1,Policies,Traits1>& x,
-          const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) { 
+          const iterator_adaptor<Iterator2,Policies,Traits2>& y) { 
     return x.policies().less(y.iter(), x.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
 inline bool 
-operator>=(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x, const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
+operator>=(const iterator_adaptor<Iterator1,Policies,Traits1>& x, const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
     return !x.policies().less(x.iter(), y.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
 inline bool 
-operator<=(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x,
+operator<=(const iterator_adaptor<Iterator1,Policies,Traits1>& x,
-           const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
+           const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
     return !x.policies().less(y.iter(), x.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
 inline bool 
-operator!=(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x, 
+operator!=(const iterator_adaptor<Iterator1,Policies,Traits1>& x, 
-           const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
+           const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
     return !x.policies().equal(x.iter(), y.iter());
 }
 #endif
@@ -334,23 +334,26 @@ operator!=(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>&
 template <class Iterator, class ConstIterator, 
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
           class Traits, 
-          class ConstTraits, 
+          class ConstTraits,
 #else
           class Traits = std::iterator_traits<Iterator>, 
-          class ConstTraits = std::iterator_traits<ConstIterator>, 
+          class ConstTraits = std::iterator_traits<ConstIterator>,
 #endif
           class Policies = default_iterator_policies>
 class iterator_adaptors
 {
 public:
-    typedef iterator_adaptor<Iterator, Policies, Traits, Iterator> iterator;
+    typedef iterator_adaptor<Iterator, Policies, Traits> iterator;
-    typedef iterator_adaptor<ConstIterator, Policies, ConstTraits, Iterator> 
+    typedef iterator_adaptor<ConstIterator, Policies, ConstTraits> 
       const_iterator;
 };
 
 
 //=============================================================================
 // Transform Iterator Adaptor
+//
+// Upon deference, apply some unary function object and return the
+// result by value.
 
 template <class AdaptableUnaryFunction>
 struct transform_iterator_policies : public default_iterator_policies
@@ -359,8 +362,8 @@ struct transform_iterator_policies : public default_iterator_policies
     transform_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
     
     template <class Reference, class Iterator>
-    Reference dereference(type<Reference>, const Iterator& x) const
+    Reference dereference(type<Reference>, const Iterator& iter) const
-        { return m_f(*x); }
+        { return m_f(*iter); }
 
     AdaptableUnaryFunction m_f;
 };
@@ -387,15 +390,24 @@ struct transform_iterator
     typedef transform_iterator_traits<AdaptableUnaryFunction,Traits>
       TransTraits;
     typedef iterator_adaptor<Iterator, 
-      transform_iterator_policies<AdaptableUnaryFunction>, TransTraits, 
+      transform_iterator_policies<AdaptableUnaryFunction>, TransTraits>
-      Iterator> type;
+      type;
 };
 
 
 //=============================================================================
 // Indirect Iterators Adaptor
 
-// Tried implementing this with transform_iterator, but that required
+// Given a pointer to pointers (or iterator to iterators),
+// apply a double dereference inside operator*().
+//
+// We use the term "outer" to refer to the first level iterator type
+// and "inner" to refer to the second level iterator type.  For
+// example, given T**, T* is the inner iterator type and T** is the
+// outer iterator type. Also, const T* would be the const inner
+// iterator.
+
+// We tried to implement this with transform_iterator, but that required
 // using boost::remove_ref, which is not compiler portable.
 
 struct indirect_iterator_policies : public default_iterator_policies
@@ -405,46 +417,64 @@ struct indirect_iterator_policies : public default_iterator_policies
         { return **x; }
 };
 
-template <class IndirectIterator,
+template <class OuterIterator, class InnerIterator,
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
-          class IndirectTraits,
+          class OuterTraits,
-          class Traits
+          class InnerTraits
 #else
-          class IndirectTraits = std::iterator_traits<IndirectIterator>,
+          class OuterTraits = std::iterator_traits<OuterIterator>,
-          class Traits = 
+          class InnerTraits = std::iterator_traits<InnerIterator>
-            std::iterator_traits<typename IndirectTraits::value_type>
 #endif
        >
 struct indirect_traits
 {
-    typedef typename IndirectTraits::difference_type difference_type;
+    typedef typename OuterTraits::difference_type difference_type;
-    typedef typename Traits::value_type value_type;
+    typedef typename InnerTraits::value_type value_type;
-    typedef typename Traits::pointer pointer;
+    typedef typename InnerTraits::pointer pointer;
-    typedef typename Traits::reference reference;
+    typedef typename InnerTraits::reference reference;
-    typedef typename IndirectTraits::iterator_category iterator_category;
+    typedef typename OuterTraits::iterator_category iterator_category;
 };
 
-template <class IndirectIterator, class ConstIndirectIterator,
+template <class OuterIterator,      // Mutable or Immutable, does not matter
+          class InnerIterator,      // Mutable -> mutable indirect iterator
+                                    // Immutable -> immutable indirect iterator
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
-          class IndirectTraits,
+          class OuterTraits,
-          class ConstIndirectTraits,
+          class InnerTraits
-          class Traits
 #else
-          class IndirectTraits = 
+          class OuterTraits = std::iterator_traits<OuterIterator>,
-              std::iterator_traits<IndirectIterator>,
+          class InnerTraits = std::iterator_traits<InnerIterator>
-          class ConstIndirectTraits = 
+#endif
-              std::iterator_traits<ConstIndirectIterator>,
+           >
-          class Traits =
+struct indirect_iterator
-              std::iterator_traits<typename IndirectTraits::value_type>
+{
+    typedef iterator_adaptor<OuterIterator,
+        indirect_iterator_policies,
+        indirect_traits<OuterIterator, InnerIterator,
+                        OuterTraits, InnerTraits>
+    > type;
+};
+
+template <class OuterIterator,      // Mutable or Immutable, does not matter
+          class InnerIterator,      // Mutable
+          class ConstInnerIterator, // Immutable
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+          class OuterTraits,
+          class InnerTraits,
+          class ConstInnerTraits
+#else
+          class OuterTraits = std::iterator_traits<OuterIterator>,
+          class InnerTraits = std::iterator_traits<InnerIterator>,
+          class ConstInnerTraits = std::iterator_traits<ConstInnerIterator>
 #endif
            >
 struct indirect_iterators
 {
-    typedef typename IndirectTraits::value_type Iterator;
+    typedef iterator_adaptors<OuterIterator, OuterIterator,
-    typedef typename Traits::value_type ValueType;
+        indirect_traits<OuterIterator, InnerIterator,
-    typedef iterator_adaptors<IndirectIterator, ConstIndirectIterator,
+                        OuterTraits, InnerTraits>,
-        indirect_traits<IndirectIterator, IndirectTraits, Traits>,
+        indirect_traits<OuterIterator, ConstInnerIterator,
-        indirect_traits<ConstIndirectIterator, ConstIndirectTraits, Traits>,
+                        OuterTraits, ConstInnerTraits>,
         indirect_iterator_policies
         > Adaptors;
     typedef typename Adaptors::iterator iterator;
@@ -475,7 +505,7 @@ struct reverse_iterator_policies
     
     template <class Difference, class Iterator1, class Iterator2>
     Difference distance(type<Difference>, const Iterator1& x, 
-			const Iterator2& y) const
+                        const Iterator2& y) const
         { return x - y; }
     
     template <class Iterator1, class Iterator2>
@@ -487,6 +517,32 @@ struct reverse_iterator_policies
         { return y < x; }
 };
   
+template <class Iterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+          class Traits = std::iterator_traits<Iterator>
+#else
+          class Traits
+#endif
+         >
+struct reverse_iterator
+{
+    typedef iterator_adaptor<Iterator, reverse_iterator_policies,
+        Traits> type;
+};
+
+template <class ConstIterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+          class ConstTraits = std::iterator_traits<ConstIterator>
+#else
+          class ConstTraits
+#endif
+         >
+struct const_reverse_iterator
+{
+    typedef iterator_adaptor<ConstIterator, reverse_iterator_policies,
+        ConstTraits> type;
+};
+
 template <class Iterator, class ConstIterator,
 #ifndef BOOST_NO_STD_ITERATOR_TRAITS
           class Traits = std::iterator_traits<Iterator>, 
@@ -504,7 +560,95 @@ struct reverse_iterators
     typedef typename Adaptor::const_iterator const_iterator;
 };
 
+//=============================================================================
+// Projection Iterators Adaptor
+
+template <class AdaptableUnaryFunction>
+struct projection_iterator_policies : public default_iterator_policies
+{
+    projection_iterator_policies() { }
+    projection_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
+
+    template <class Reference, class Iterator>
+    Reference dereference (type<Reference>, Iterator const& iter) const {
+        return m_f(*iter);
+    }
+
+    AdaptableUnaryFunction m_f;    
+};
+
+template <class AdaptableUnaryFunction, class Traits>
+struct projection_iterator_traits {
+    typedef typename AdaptableUnaryFunction::result_type value_type;
+    typedef value_type& reference;
+    typedef value_type* pointer;
+    typedef typename Traits::difference_type difference_type;
+    typedef typename Traits::iterator_category iterator_category;
+};
+
+template <class AdaptableUnaryFunction, class Traits>
+struct const_projection_iterator_traits {
+    typedef typename AdaptableUnaryFunction::result_type value_type;
+    typedef value_type const& reference;
+    typedef value_type const* pointer;
+    typedef typename Traits::difference_type difference_type;
+    typedef typename Traits::iterator_category iterator_category;
+};
+
+template <class AdaptableUnaryFunction, class Iterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+        class Traits = std::iterator_traits<Iterator>
+#else
+        class Traits
+#endif
+        >
+struct projection_iterator {
+    typedef projection_iterator_traits<AdaptableUnaryFunction, Traits>
+            Projection_Traits;
+    typedef iterator_adaptor<Iterator,
+            projection_iterator_policies<AdaptableUnaryFunction>,
+            Projection_Traits> type;
+};
+
+template <class AdaptableUnaryFunction, class Iterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+        class Traits = std::iterator_traits<Iterator>
+#else
+        class Traits
+#endif
+        >
+struct const_projection_iterator {
+    typedef const_projection_iterator_traits<AdaptableUnaryFunction,
+            Traits> Projection_Traits;
+    typedef iterator_adaptor<Iterator,
+            projection_iterator_policies<AdaptableUnaryFunction>,
+            Projection_Traits> type;
+};
+
+template <class AdaptableUnaryFunction, class Iterator, class ConstIterator,
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+        class Traits = std::iterator_traits<Iterator>,
+        class ConstTraits = std::iterator_traits<ConstIterator>
+#else
+        class Traits,
+        class ConstTraits
+#endif
+        >
+struct projection_iterators {
+    typedef projection_iterator_traits<AdaptableUnaryFunction, Traits>
+            Projection_Traits;
+    typedef const_projection_iterator_traits<AdaptableUnaryFunction,
+            ConstTraits> Const_Projection_Traits;
+    typedef iterator_adaptors<Iterator, ConstIterator,
+            Projection_Traits, Const_Projection_Traits,
+            projection_iterator_policies<AdaptableUnaryFunction> > Adaptors;
+    typedef typename Adaptors::iterator iterator;
+    typedef typename Adaptors::const_iterator const_iterator;
+};
+
 } // namespace boost
 
 #endif
 
+
+

include/boost/pending/iterator_tests.hpp

@@ -141,7 +141,8 @@ void random_access_iterator_test(Iterator i, int N, TrueVals vals)
     assert(i == k - c);
     assert(*i == vals[N - 1 - c]);
     assert(*i == j[N - 1 - c]);
-    assert(*i == *(k - c));
+    Iterator q = k - c; 
+    assert(*i == *q);
     assert(i > j);
     assert(i >= j);
     assert(j <= i);