This commit was manufactured by cvs2svn to create branch 'regex-sub'.

[SVN r7754]

include/boost/iterator.hpp

@@ -0,0 +1,58 @@
+//  integer.hpp workarounds for non-conforming standard libraries  -----------//
+
+//  (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+//  See http://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  28 Jun 00 Workarounds to deal with known MSVC bugs (David Abrahams)
+//  26 Jun 00 Initial version (Jeremy Siek)
+
+#ifndef BOOST_ITERATOR_HPP
+#define BOOST_ITERATOR_HPP
+
+#include <iterator>
+#include <boost/config.hpp>
+
+namespace boost
+{
+# ifdef BOOST_NO_STD_ITERATOR
+  template <class Category, class T,
+    class Distance = std::ptrdiff_t,
+    class Pointer = T*, class Reference = T&>
+  struct iterator
+  {
+    typedef T         value_type;
+    typedef Distance  difference_type;
+    typedef Pointer   pointer;
+    typedef Reference reference;
+    typedef Category  iterator_category;
+  };
+# else
+
+  // declare iterator_base in namespace detail to work around MSVC bugs which
+  // prevent derivation from an identically-named class in a different namespace.
+  namespace detail {
+   template <class Category, class T, class Distance, class Pointer, class Reference>
+#  if !defined(BOOST_MSVC_STD_ITERATOR)
+   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
+#  else
+   struct iterator_base : std::iterator<Category, T, Distance>
+   {
+     typedef Reference reference;
+     typedef Pointer pointer;
+     typedef Distance difference_type;
+   };
+#  endif
+  }
+
+  template <class Category, class T, class Distance = std::ptrdiff_t,
+            class Pointer = T*, class Reference = T&>
+   struct iterator : detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
+# endif
+} // namespace boost
+
+#endif // BOOST_ITERATOR_HPP

include/boost/pending/detail/int_iterator.hpp

@@ -0,0 +1,68 @@
+//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
+//  sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+#ifndef BOOST_INT_ITERATOR_H
+#define BOOST_INT_ITERATOR_H
+
+#include <boost/iterator.hpp>
+#if !defined BOOST_MSVC
+#include <boost/operators.hpp>
+#endif
+#include <iostream>
+//using namespace std;
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost {
+#endif
+
+// this should use random_access_iterator_helper but I've had
+// VC++ portablility problems with that. -JGS
+template <class IntT>
+class int_iterator
+{
+  typedef int_iterator self;
+public:
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef IntT value_type;
+  typedef IntT& reference;
+  typedef IntT* pointer;
+  typedef ptrdiff_t difference_type;
+
+  inline int_iterator() : _i(0) { }
+  inline int_iterator(IntT i) : _i(i) { }
+  inline int_iterator(const self& x) : _i(x._i) { }
+  inline self& operator=(const self& x) { _i = x._i; return *this; }
+  inline IntT operator*() { return _i; }
+  inline IntT operator[](IntT n) { return _i + n; }
+  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--() { --_i; return *this; }
+  inline self operator--(int) { self t = *this; --_i; return t; }
+  inline self& operator-=(IntT n) { _i -= n; return *this; }
+  inline IntT operator-(const self& x) const { return _i - x._i; }
+  inline bool operator==(const self& x) const { return _i == x._i; }
+  // vc++ had a problem finding != in random_access_iterator_helper
+  // 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; }
+protected:
+  IntT _i;
+};
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+} /* namespace boost */
+#endif
+
+#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost {
+  using ::int_iterator;
+}
+#endif
+
+
+#endif /* BOOST_INT_ITERATOR_H */

include/boost/pending/integer_range.hpp

@@ -0,0 +1,76 @@
+// (C) Copyright David Abrahams 2000. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+//
+// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
+// sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#ifndef BOOST_INTEGER_RANGE_HPP_
+#define BOOST_INTEGER_RANGE_HPP_
+
+#ifdef BOOST_MSVC
+#include <boost/pending/detail/int_iterator.hpp>
+#else
+#include <boost/pending/iterator_adaptors.hpp>
+#endif
+
+namespace boost {
+
+//=============================================================================
+// Counting Iterator and Integer Range Class
+
+struct counting_iterator_policies : public default_iterator_policies
+{
+    template <class IntegerType>
+    IntegerType dereference(type<IntegerType>, const IntegerType& i) const
+        { return i; }
+};
+template <class IntegerType>
+struct counting_iterator_traits {
+    typedef IntegerType value_type;
+    typedef IntegerType reference;
+    typedef value_type* pointer;
+    typedef std::ptrdiff_t difference_type;
+    typedef std::random_access_iterator_tag iterator_category;
+};
+
+template <class IntegerType>
+struct integer_range {
+#ifdef BOOST_MSVC
+    typedef int_iterator<IntegerType> iterator;
+#else
+    typedef iterator_adaptor<IntegerType, counting_iterator_policies,
+      counting_iterator_traits<IntegerType>, IntegerType> iterator;
+#endif
+    typedef iterator const_iterator;
+    typedef IntegerType value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef IntegerType reference;
+    typedef IntegerType const_reference;
+    typedef const IntegerType* pointer;
+    typedef const IntegerType* const_pointer;
+    typedef IntegerType size_type;
+
+    integer_range(IntegerType start, IntegerType finish)
+        : m_start(start), m_finish(finish) { }
+
+    iterator begin() const { return iterator(m_start); }
+    iterator end() const { return iterator(m_finish); }
+    size_type size() const { return m_finish - m_start; }
+    bool empty() const { return m_finish == m_start; }
+    void swap(integer_range& x) {
+        std::swap(m_start, x.m_start);
+        std::swap(m_finish, x.m_finish);
+    }
+protected:
+    IntegerType m_start, m_finish;
+};
+
+} // namespace boost
+
+#endif // BOOST_INTEGER_RANGE_HPP_

include/boost/pending/iterator_adaptors.hpp

@@ -13,15 +13,15 @@
 #ifndef BOOST_ITERATOR_ADAPTOR_DWA053000_HPP_
 #define BOOST_ITERATOR_ADAPTOR_DWA053000_HPP_
 
-#include <boost/iterator.hpp>
+#include <iterator>
 #include <boost/utility.hpp>
+#include <boost/operators.hpp>
 #include <boost/compressed_pair.hpp>
-#include <boost/concept_check.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" if it doesn't work. -dwa 7/31/00
+// off. Now we can test the hack with various compilers and still have an "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,122 +32,37 @@ namespace boost {
 template <class T>
 struct type {};
 
-
-//============================================================================
-// Concept checking classes that express the requirements for iterator
-// policies and adapted types. These classes are mostly for
-// documentation purposes, and are not used in this header file. They
-// merely provide a more succinct statement of what is expected of the
-// iterator policies.
-
-template <class Policies, class Adapted, class Traits>
-struct TrivialIteratorPoliciesConcept
-{
-  typedef typename Traits::reference Reference;
-  void constraints() {
-    function_requires< AssignableConcept<Policies> >();
-    function_requires< DefaultConstructibleConcept<Policies> >();
-    function_requires< AssignableConcept<Adapted> >();
-    function_requires< DefaultConstructibleConcept<Adapted> >();
-
-    const_constraints();
-  }
-  void const_constraints() const {
-    Reference r = p.dereference(type<Reference>(), x);
-    b = p.equal(x, x);
-  }
-  Policies p;
-  Adapted x;
-  mutable bool b;
-};
-
-template <class Policies, class Adapted, class Traits>
-struct ForwardIteratorPoliciesConcept
-{
-  void constraints() {
-    function_requires< 
-      TrivialIteratorPoliciesConcept<Policies, Adapted, Traits>
-      >();
-
-    p.increment(x);
-  }
-  Policies p;
-  Adapted x;
-};
-
-template <class Policies, class Adapted, class Traits>
-struct BidirectionalIteratorPoliciesConcept
-{
-  void constraints() {
-    function_requires< 
-      ForwardIteratorPoliciesConcept<Policies, Adapted, Traits>
-      >();
-
-    p.decrement(x);
-  }
-  Policies p;
-  Adapted x;
-};
-
-template <class Policies, class Adapted, class Traits>
-struct RandomAccessIteratorPoliciesConcept
-{
-  typedef typename Traits::difference_type DifferenceType;
-  void constraints() {
-    function_requires< 
-      BidirectionalIteratorPoliciesConcept<Policies, Adapted, Traits>
-      >();
-
-    p.advance(x, n);
-    const_constraints();
-  }
-  void const_constraints() const {
-    n = p.distance(type<DifferenceType>(), x, x);
-    b = p.less(x, x);
-  }
-  Policies p;
-  Adapted x;
-  mutable DifferenceType n;
-  mutable bool b;
-};
-
-
-//============================================================================
+//=============================================================================
 // 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>
-    Reference dereference(type<Reference>, const Iterator& x) const
+    static Reference dereference(type<Reference>, const Iterator& x)
         { return *x; }
 
     template <class Iterator>
-    void increment(Iterator& x)
+    static void increment(Iterator& x)
         { ++x; }
 
     template <class Iterator>
-    void decrement(Iterator& x)
+    static void decrement(Iterator& x)
         { --x; }
 
     template <class Iterator, class DifferenceType>
-    void advance(Iterator& x, DifferenceType n)
+    static void advance(Iterator& x, DifferenceType n)
         { x += n; }
 
     template <class Difference, class Iterator1, class Iterator2>
-    Difference distance(type<Difference>, const Iterator1& x,
-                        const Iterator2& y) const
+    static Difference distance(type<Difference>, const Iterator1& x, const Iterator2& y)
         { return y - x; }
 
     template <class Iterator1, class Iterator2>
-    bool equal(const Iterator1& x, const Iterator2& y) const
+    static bool equal(const Iterator1& x, const Iterator2& y)
         { return x == y; }
 
     template <class Iterator1, class Iterator2>
-    bool less(const Iterator1& x, const Iterator2& y) const
+    static bool less(const Iterator1& x, const Iterator2& y)
         { return x < y; }
 };
 
@@ -213,46 +128,7 @@ inline bool operator<=(const iterator_comparisons<D1,Base1>& xb,
 }
 #endif
 
-//============================================================================
-// Some compilers (SGI MIPSpro 7.1.3.3) instantiate/compile member functions
-// whether or not they are used. The following functions make sure that
-// when the base iterators do not support particular operators, those
-// operators do not get used.
-
-namespace detail {
-
-  // Dummy version for iterators that don't support member access
-  template <class Iter, class Cat>
-  inline typename Iter::pointer
-  operator_arrow(const Iter&, Cat) {
-    typedef typename Iter::pointer Pointer;
-    return Pointer();
-  }
-  // Real version
-  template <class Iter>
-  inline typename Iter::pointer
-  operator_arrow(const Iter& i, std::forward_iterator_tag) {
-    return &(*i);
-  }
-
-  // Dummy version for iterators that don't support member access
-  template <class Iter, class Diff, class Cat>
-  inline void advance_impl(const Iter&, Diff, Cat) { }
-
-  // Real version
-  template <class Iter, class Diff>
-  inline typename Iter::pointer
-  advance_impl(const Iter& i, Diff n, std::random_access_iterator_tag) {
-#ifdef __MWERKS__
-        i.policies().advance<Iter>(iter(), n);
-#else
-        i.policies().advance(iter(), n);
-#endif
-  }
-
-} // namespace detail
-
-//============================================================================
+//=============================================================================
 // iterator_adaptor - A generalized adaptor around an existing
 //   iterator, which is itself an iterator
 //
@@ -264,17 +140,22 @@ namespace detail {
 //   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>,
+          iterator_adaptor<Iterator,Policies,Traits,NonconstIterator>,
 #endif
           boost::iterator<typename Traits::iterator_category, 
               typename Traits::value_type, typename Traits::difference_type,
@@ -283,26 +164,45 @@ struct iterator_adaptor :
 >
 #endif
 {
-    typedef iterator_adaptor<Iterator, Policies, Traits> Self;
+    typedef iterator_adaptor<Iterator, Policies, Traits,NonconstIterator> 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) {}
 
-    template <class OtherIter, class OtherTraits>
-    iterator_adaptor (const iterator_adaptor<OtherIter, Policies,
-            OtherTraits>& src)
-            : m_iter_p(src.iter(), src.policies()) {
+#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
+    template <class MutableIterator, class OtherTraits>
+    iterator_adaptor(const iterator_adaptor<MutableIterator, Policies, OtherTraits, NonconstIterator>& rhs)
+        : m_iter_p(rhs.iter(), rhs.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());
     }
@@ -313,51 +213,39 @@ public:
 #endif
 
     pointer operator->() const
-        { return detail::operator_arrow(*this, iterator_category()); }
+        { return &*this; }
 
 #ifdef _MSC_VER
 # pragma warning(pop)
 #endif
 
-    reference operator[](difference_type n) const
+    reference operator[](difference_type n)
         { 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) {
-        detail::advance_impl(*this, n, iterator_category());
+        policies().advance(iter(), n);
         return *this;
     }
   
     Self& operator-=(difference_type n) {
-        detail::advance_impl(*this, -n, iterator_category());
+        policies().advance(iter(), -n);
         return *this;
     }
 
-    iterator_type base() const { return m_iter_p.first(); }
-
 private:
     typedef Policies policies_type;
     compressed_pair<Iterator,Policies> m_iter_p;
@@ -368,74 +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>
-iterator_adaptor<Iterator,Policies,Traits>
-operator-(iterator_adaptor<Iterator,Policies,Traits> p, const typename Traits::difference_type x)
+template <class Iterator, class Policies, class Traits, class NonconstIterator>
+iterator_adaptor<Iterator,Policies,Traits,NonconstIterator>
+operator-(iterator_adaptor<Iterator,Policies,Traits,NonconstIterator> p, const typename Traits::difference_type x)
 {
     return p -= x;
 }
 
-template <class Iterator, class Policies, class Traits>
-iterator_adaptor<Iterator,Policies,Traits>
-operator+(iterator_adaptor<Iterator,Policies,Traits> p, typename Traits::difference_type x)
+template <class Iterator, class Policies, class Traits, class NonconstIterator>
+iterator_adaptor<Iterator,Policies,Traits,NonconstIterator>
+operator+(iterator_adaptor<Iterator,Policies,Traits,NonconstIterator> p, const typename Traits::difference_type x)
 {
     return p += x;
 }
 
-template <class Iterator, class Policies, class Traits>
-iterator_adaptor<Iterator,Policies,Traits>
-operator+(typename Traits::difference_type x, iterator_adaptor<Iterator,Policies,Traits> p)
+template <class Iterator, class Policies, class Traits, class NonconstIterator>
+iterator_adaptor<Iterator,Policies,Traits,NonconstIterator>
+operator+(const typename Traits::difference_type x, iterator_adaptor<Iterator,Policies,Traits,NonconstIterator> p)
 {
     return p += x;
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
 typename Traits1::difference_type operator-(
-    const iterator_adaptor<Iterator1,Policies,Traits1>& x,
-    const iterator_adaptor<Iterator2,Policies,Traits2>& y )
+    const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x,
+    const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& 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>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
 inline bool 
-operator==(const iterator_adaptor<Iterator1,Policies,Traits1>& x, const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+operator==(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x, const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
     return x.policies().equal(x.iter(), y.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
 inline bool 
-operator<(const iterator_adaptor<Iterator1,Policies,Traits1>& x, const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+operator<(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x, const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
     return x.policies().less(x.iter(), y.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
 inline bool 
-operator>(const iterator_adaptor<Iterator1,Policies,Traits1>& x,
-          const iterator_adaptor<Iterator2,Policies,Traits2>& y) { 
+operator>(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x,
+          const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) { 
     return x.policies().less(y.iter(), x.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
 inline bool 
-operator>=(const iterator_adaptor<Iterator1,Policies,Traits1>& x, const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+operator>=(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x, const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
     return !x.policies().less(x.iter(), y.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
 inline bool 
-operator<=(const iterator_adaptor<Iterator1,Policies,Traits1>& x,
-           const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+operator<=(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x,
+           const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
     return !x.policies().less(y.iter(), x.iter());
 }
 
-template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2>
+template <class Iterator1, class Iterator2, class Policies, class Traits1, class Traits2, class NonconstIterator>
 inline bool 
-operator!=(const iterator_adaptor<Iterator1,Policies,Traits1>& x, 
-           const iterator_adaptor<Iterator2,Policies,Traits2>& y) {
+operator!=(const iterator_adaptor<Iterator1,Policies,Traits1,NonconstIterator>& x, 
+           const iterator_adaptor<Iterator2,Policies,Traits2,NonconstIterator>& y) {
     return !x.policies().equal(x.iter(), y.iter());
 }
 #endif
@@ -447,26 +334,23 @@ operator!=(const iterator_adaptor<Iterator1,Policies,Traits1>& x,
 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;
-    typedef iterator_adaptor<ConstIterator, Policies, ConstTraits> 
+    typedef iterator_adaptor<Iterator, Policies, Traits, Iterator> iterator;
+    typedef iterator_adaptor<ConstIterator, Policies, ConstTraits, Iterator> 
       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
@@ -475,8 +359,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& iter) const
-        { return m_f(*iter); }
+    Reference dereference(type<Reference>, const Iterator& x) const
+        { return m_f(*x); }
 
     AdaptableUnaryFunction m_f;
 };
@@ -503,24 +387,15 @@ struct transform_iterator
     typedef transform_iterator_traits<AdaptableUnaryFunction,Traits>
       TransTraits;
     typedef iterator_adaptor<Iterator, 
-      transform_iterator_policies<AdaptableUnaryFunction>, TransTraits>
-      type;
+      transform_iterator_policies<AdaptableUnaryFunction>, TransTraits, 
+      Iterator> type;
 };
 
 
 //=============================================================================
 // Indirect Iterators Adaptor
 
-// 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
+// Tried implementing this with transform_iterator, but that required
 // using boost::remove_ref, which is not compiler portable.
 
 struct indirect_iterator_policies : public default_iterator_policies
@@ -530,64 +405,46 @@ struct indirect_iterator_policies : public default_iterator_policies
         { return **x; }
 };
 
-template <class OuterIterator, class InnerIterator,
+template <class IndirectIterator,
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
-          class OuterTraits,
-          class InnerTraits
+          class IndirectTraits,
+          class Traits
 #else
-          class OuterTraits = std::iterator_traits<OuterIterator>,
-          class InnerTraits = std::iterator_traits<InnerIterator>
+          class IndirectTraits = std::iterator_traits<IndirectIterator>,
+          class Traits = 
+            std::iterator_traits<typename IndirectTraits::value_type>
 #endif
        >
 struct indirect_traits
 {
-    typedef typename OuterTraits::difference_type difference_type;
-    typedef typename InnerTraits::value_type value_type;
-    typedef typename InnerTraits::pointer pointer;
-    typedef typename InnerTraits::reference reference;
-    typedef typename OuterTraits::iterator_category iterator_category;
+    typedef typename IndirectTraits::difference_type difference_type;
+    typedef typename Traits::value_type value_type;
+    typedef typename Traits::pointer pointer;
+    typedef typename Traits::reference reference;
+    typedef typename IndirectTraits::iterator_category iterator_category;
 };
 
-template <class OuterIterator,      // Mutable or Immutable, does not matter
-          class InnerIterator,      // Mutable -> mutable indirect iterator
-                                    // Immutable -> immutable indirect iterator
+template <class IndirectIterator, class ConstIndirectIterator,
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
-          class OuterTraits,
-          class InnerTraits
+          class IndirectTraits,
+          class ConstIndirectTraits,
+          class Traits
 #else
-          class OuterTraits = std::iterator_traits<OuterIterator>,
-          class InnerTraits = std::iterator_traits<InnerIterator>
-#endif
-           >
-struct indirect_iterator
-{
-    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>
+          class IndirectTraits = 
+              std::iterator_traits<IndirectIterator>,
+          class ConstIndirectTraits = 
+              std::iterator_traits<ConstIndirectIterator>,
+          class Traits =
+              std::iterator_traits<typename IndirectTraits::value_type>
 #endif
            >
 struct indirect_iterators
 {
-    typedef iterator_adaptors<OuterIterator, OuterIterator,
-        indirect_traits<OuterIterator, InnerIterator,
-                        OuterTraits, InnerTraits>,
-        indirect_traits<OuterIterator, ConstInnerIterator,
-                        OuterTraits, ConstInnerTraits>,
+    typedef typename IndirectTraits::value_type Iterator;
+    typedef typename Traits::value_type ValueType;
+    typedef iterator_adaptors<IndirectIterator, ConstIndirectIterator,
+        indirect_traits<IndirectIterator, IndirectTraits, Traits>,
+        indirect_traits<ConstIndirectIterator, ConstIndirectTraits, Traits>,
         indirect_iterator_policies
         > Adaptors;
     typedef typename Adaptors::iterator iterator;
@@ -618,7 +475,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>
@@ -630,32 +487,6 @@ 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>, 
@@ -673,95 +504,7 @@ 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

@@ -0,0 +1,171 @@
+#ifndef BOOST_ITERATOR_TESTS_HPP
+#define BOOST_ITERATOR_TESTS_HPP
+
+// This is meant to be the beginnings of a comprehensive, generic
+// test suite for STL concepts such as iterators and containers.
+
+#include <assert.h>
+
+namespace boost {
+
+  // use this for the value type
+struct dummyT { 
+  dummyT() { }
+  dummyT(int x) : m_x(x) { }
+  int foo() const { return m_x; } 
+  bool operator==(const dummyT& d) const { return m_x == d.m_x; }
+  int m_x;
+};
+
+
+// Tests whether type Iterator satisfies the requirements for a
+// TrivialIterator. 
+// Preconditions: i != j, *i == val
+template <class Iterator, class T>
+void trivial_iterator_test(Iterator i, Iterator j, T val)
+{
+  Iterator k;
+  assert(i == i);
+  assert(j == j);
+  assert(i != j);
+#ifdef BOOST_NO_STD_ITERATOR_TRAITS
+  T v = *i;
+#else
+  typename std::iterator_traits<Iterator>::value_type v = *i;
+#endif
+  assert(v == val);
+#if 0
+  // hmm, this will give a warning for transform_iterator...  perhaps
+  // this should be separated out into a stand-alone test since there
+  // are several situations where it can't be used, like for
+  // integer_range::iterator.
+  assert(v == i->foo());
+#endif
+  k = i;
+  assert(k == k);
+  assert(k == i);
+  assert(k != j);
+  assert(*k == val);
+}
+
+
+// Preconditions: i != j
+template <class Iterator, class T>
+void mutable_trivial_iterator_test(Iterator i, Iterator j, T val)
+{
+  *i = val;
+  trivial_iterator_test(i, j, val);
+}
+
+
+// Preconditions: *i == v1, *++i == v2
+template <class Iterator, class T>
+void input_iterator_test(Iterator i, T v1, T v2) 
+{
+  Iterator i1 = i, i2 = i;
+
+  assert(i == i1++);
+  assert(i != ++i2);
+
+  trivial_iterator_test(i, i1, v1);
+  trivial_iterator_test(i, i2, v1);
+
+  ++i;
+  assert(i == i1);
+  assert(i == i2);
+  ++i1;
+  ++i2;
+
+  trivial_iterator_test(i, i1, v2);
+  trivial_iterator_test(i, i2, v2);
+}
+
+// how to test output iterator?
+
+template <class Iterator, class T>
+void forward_iterator_test(Iterator i, T v1, T v2) 
+{
+  input_iterator_test(i, v1, v2);
+}
+
+// Preconditions: *i == v1, *++i == v2
+template <class Iterator, class T>
+void bidirectional_iterator_test(Iterator i, T v1, T v2)
+{
+  input_iterator_test(i, v1, v2);
+  ++i;
+
+  Iterator i1 = i, i2 = i;
+
+  assert(i == i1--);
+  assert(i != --i2);
+
+  trivial_iterator_test(i, i1, v2);
+  trivial_iterator_test(i, i2, v2);
+
+  --i;
+  assert(i == i1);
+  assert(i == i2);
+  --i1;
+  --i2;
+
+  trivial_iterator_test(i, i1, v1);
+  trivial_iterator_test(i, i2, v1);
+}
+
+// mutable_bidirectional_iterator_test
+
+// Preconditions: [i,i+N) is a valid range
+template <class Iterator, class TrueVals>
+void random_access_iterator_test(Iterator i, int N, TrueVals vals)
+{
+  bidirectional_iterator_test(i, vals[0], vals[1]);
+  Iterator j = i;
+  int c;
+
+  for (c = 0; c < N-1; ++c) {
+    assert(i == j + c);
+    assert(*i == vals[c]);
+    assert(*i == j[c]);
+    assert(*i == *(j + c));
+    assert(*i == *(c + j));
+    ++i;
+    assert(i > j);
+    assert(i >= j);
+    assert(j <= i);
+    assert(j < i);
+  }
+
+  Iterator k = j + N - 1;
+  for (c = 0; c < N-1; ++c) {
+    assert(i == k - c);
+    assert(*i == vals[N - 1 - c]);
+    assert(*i == j[N - 1 - c]);
+    assert(*i == *(k - c));
+    assert(i > j);
+    assert(i >= j);
+    assert(j <= i);
+    assert(j < i);
+    --i;
+  }
+}
+
+// Precondition: i != j
+template <class Iterator, class ConstIterator>
+void const_nonconst_iterator_test(Iterator i, ConstIterator j)
+{
+  assert(i != j);
+  assert(j != i);
+
+  ConstIterator k(i);
+  assert(k == i);
+  assert(i == k);
+
+  k = i;
+  assert(k == i);
+  assert(i == k);
+}
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_TESTS_HPP