Try a new interface

[SVN r9061]

include/boost/iterator.hpp

@@ -1,58 +0,0 @@
-//  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

@@ -1,68 +0,0 @@
-//  (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

@@ -1,76 +0,0 @@
-// (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

@@ -1,510 +0,0 @@
-// (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_ITERATOR_ADAPTOR_DWA053000_HPP_
-#define BOOST_ITERATOR_ADAPTOR_DWA053000_HPP_
-
-#include <iterator>
-#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"
-// 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
-
-namespace boost {
-
-// Just a "type envelope"; works around some MSVC deficiencies.
-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
-{
-    template <class Reference, class Iterator>
-    static Reference dereference(type<Reference>, const Iterator& x)
-        { return *x; }
-
-    template <class Iterator>
-    static void increment(Iterator& x)
-        { ++x; }
-
-    template <class Iterator>
-    static void decrement(Iterator& x)
-        { --x; }
-
-    template <class Iterator, class DifferenceType>
-    static 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)
-        { return y - x; }
-
-    template <class Iterator1, class Iterator2>
-    static bool equal(const Iterator1& x, const Iterator2& y)
-        { return x == y; }
-
-    template <class Iterator1, class Iterator2>
-    static bool less(const Iterator1& x, const Iterator2& y)
-        { return x < y; }
-};
-
-// putting the comparisons in a base class avoids the g++ 
-// ambiguous overload bug due to the relops operators
-
-#ifdef BOOST_RELOPS_AMBIGUITY_BUG
-template <class Derived, class Base>
-struct iterator_comparisons : Base { };
-
-template <class D1, class D2, class Base1, class Base2>
-inline bool operator==(const iterator_comparisons<D1,Base1>& xb, 
-                       const iterator_comparisons<D2,Base2>& yb)
-{
-        const D1& x = static_cast<const D1&>(xb);
-    const D2& y = static_cast<const D2&>(yb);
-    return x.policies().equal(x.iter(), y.iter());
-}
-
-template <class D1, class D2, class Base1, class Base2>
-inline bool operator!=(const iterator_comparisons<D1,Base1>& xb, 
-                       const iterator_comparisons<D2,Base2>& yb)
-{
-    const D1& x = static_cast<const D1&>(xb);
-    const D2& y = static_cast<const D2&>(yb);
-    return !x.policies().equal(x.iter(), y.iter());
-}
-
-template <class D1, class D2, class Base1, class Base2>
-inline bool operator<(const iterator_comparisons<D1,Base1>& xb, 
-                      const iterator_comparisons<D2,Base2>& yb)
-{
-    const D1& x = static_cast<const D1&>(xb);
-    const D2& y = static_cast<const D2&>(yb);
-    return x.policies().less(x.iter(), y.iter());
-}
-
-template <class D1, class D2, class Base1, class Base2>
-inline bool operator>(const iterator_comparisons<D1,Base1>& xb, 
-                      const iterator_comparisons<D2,Base2>& yb)
-{ 
-    const D1& x = static_cast<const D1&>(xb);
-    const D2& y = static_cast<const D2&>(yb);
-    return x.policies().less(y.iter(), x.iter());
-}
-
-template <class D1, class D2, class Base1, class Base2>
-inline bool operator>=(const iterator_comparisons<D1,Base1>& xb, 
-                       const iterator_comparisons<D2,Base2>& yb)
-{
-    const D1& x = static_cast<const D1&>(xb);
-    const D2& y = static_cast<const D2&>(yb);
-    return !x.policies().less(x.iter(), y.iter());
-}
-
-template <class D1, class D2, class Base1, class Base2>
-inline bool operator<=(const iterator_comparisons<D1,Base1>& xb, 
-                       const iterator_comparisons<D2,Base2>& yb)
-{
-    const D1& x = static_cast<const D1&>(xb);
-    const D2& y = static_cast<const D2&>(yb);
-    return !x.policies().less(y.iter(), x.iter());
-}
-#endif
-
-//=============================================================================
-// iterator_adaptor - A generalized adaptor around an existing
-//   iterator, which is itself an iterator
-//
-//   Iterator - the iterator type being wrapped.
-//
-//   Policies - a set of policies determining how the resulting iterator
-//      works.
-//
-//   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,
-#else
-          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>,
-#endif
-          boost::iterator<typename Traits::iterator_category, 
-              typename Traits::value_type, typename Traits::difference_type,
-              typename Traits::pointer, typename Traits::reference>
-#ifdef BOOST_RELOPS_AMBIGUITY_BUG
->
-#endif
-{
-    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;
-
-    iterator_adaptor() { }
-
-    iterator_adaptor(const Iterator& iter, const Policies& p = Policies())
-        : m_iter_p(iter, p) {}
-
-#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());
-    }
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning( disable : 4284 )
-#endif
-
-    pointer operator->() const
-        { return &*this; }
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-    reference operator[](difference_type n)
-        { return *(*this + n); }
-    
-    Self& operator++() {
-        policies().increment(iter());
-        return *this;
-    }
-
-    Self operator++(int) { Self tmp(*this); ++*this; return tmp; }
-    
-    Self& operator--() {
-        policies().decrement(iter());
-        return *this;
-    }
-    
-    Self operator--(int) { Self tmp(*this); --*this; return tmp; }
-
-    Self& operator+=(difference_type n) {
-        policies().advance(iter(), n);
-        return *this;
-    }
-  
-    Self& operator-=(difference_type n) {
-        policies().advance(iter(), -n);
-        return *this;
-    }
-
-private:
-    typedef Policies policies_type;
-    compressed_pair<Iterator,Policies> m_iter_p;
-public: // too many compilers have trouble when these are private.
-    Policies& policies() { return m_iter_p.second(); }
-    const Policies& policies() const { return m_iter_p.second(); }
-    Iterator& iter() { return m_iter_p.first(); }
-    const Iterator& iter() const { return m_iter_p.first(); }
-};
-
-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, 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, 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, class NonconstIterator>
-typename Traits1::difference_type operator-(
-    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, class NonconstIterator>
-inline bool 
-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, class NonconstIterator>
-inline bool 
-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, class NonconstIterator>
-inline bool 
-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, class NonconstIterator>
-inline bool 
-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, class NonconstIterator>
-inline bool 
-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, class NonconstIterator>
-inline bool 
-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
-
-//=============================================================================
-// iterator_adaptors - A type generator that simplifies creating
-//   mutable/const pairs of iterator adaptors.
-
-template <class Iterator, class ConstIterator, 
-#ifdef BOOST_NO_STD_ITERATOR_TRAITS
-          class Traits, 
-          class ConstTraits, 
-#else
-          class Traits = std::iterator_traits<Iterator>, 
-          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<ConstIterator, Policies, ConstTraits, Iterator> 
-      const_iterator;
-};
-
-
-//=============================================================================
-// Transform Iterator Adaptor
-
-template <class AdaptableUnaryFunction>
-struct transform_iterator_policies : public default_iterator_policies
-{
-    transform_iterator_policies() { }
-    transform_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
-    
-    template <class Reference, class Iterator>
-    Reference dereference(type<Reference>, const Iterator& x) const
-        { return m_f(*x); }
-
-    AdaptableUnaryFunction m_f;
-};
-
-template <class AdaptableUnaryFunction, class IteratorTraits>
-struct transform_iterator_traits {
-    typedef typename AdaptableUnaryFunction::result_type value_type;
-    typedef value_type reference;
-    typedef value_type* pointer;
-    typedef typename IteratorTraits::difference_type difference_type;
-    typedef typename IteratorTraits::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 transform_iterator
-{
-    typedef transform_iterator_traits<AdaptableUnaryFunction,Traits>
-      TransTraits;
-    typedef iterator_adaptor<Iterator, 
-      transform_iterator_policies<AdaptableUnaryFunction>, TransTraits, 
-      Iterator> type;
-};
-
-
-//=============================================================================
-// Indirect Iterators Adaptor
-
-// 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
-{
-    template <class Reference, class Iterator>
-    Reference dereference(type<Reference>, const Iterator& x) const
-        { return **x; }
-};
-
-template <class IndirectIterator,
-#ifdef BOOST_NO_STD_ITERATOR_TRAITS
-          class IndirectTraits,
-          class Traits
-#else
-          class IndirectTraits = std::iterator_traits<IndirectIterator>,
-          class Traits = 
-            std::iterator_traits<typename IndirectTraits::value_type>
-#endif
-       >
-struct indirect_traits
-{
-    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 IndirectIterator, class ConstIndirectIterator,
-#ifdef BOOST_NO_STD_ITERATOR_TRAITS
-          class IndirectTraits,
-          class ConstIndirectTraits,
-          class Traits
-#else
-          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 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;
-    typedef typename Adaptors::const_iterator const_iterator;
-};
-
-
-//=============================================================================
-// Reverse Iterators Adaptor
-
-struct reverse_iterator_policies
-{
-    template <class Reference, class Iterator>
-    Reference dereference(type<Reference>, const Iterator& x) const
-        { return *boost::prior(x); }
-    
-    template <class Iterator>
-    void increment(Iterator& x) const
-        { --x; }
-    
-    template <class Iterator>
-    void decrement(Iterator& x) const
-        { ++x; }
-    
-    template <class Iterator, class DifferenceType>
-    void advance(Iterator& x, DifferenceType n) const
-        { x -= n; }
-    
-    template <class Difference, class Iterator1, class Iterator2>
-    Difference distance(type<Difference>, const Iterator1& x, 
-			const Iterator2& y) const
-        { return x - y; }
-    
-    template <class Iterator1, class Iterator2>
-    bool equal(const Iterator1& x, const Iterator2& y) const
-        { return x == y; }
-    
-    template <class Iterator1, class Iterator2>
-    bool less(const Iterator1& x, const Iterator2& y) const
-        { return y < x; }
-};
-  
-template <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 reverse_iterators
-{
-    typedef iterator_adaptors<Iterator,ConstIterator,Traits,ConstTraits,
-        reverse_iterator_policies> Adaptor;
-    typedef typename Adaptor::iterator iterator;
-    typedef typename Adaptor::const_iterator const_iterator;
-};
-
-} // namespace boost
-
-#endif
-

include/boost/pending/iterator_tests.hpp

@@ -1,171 +0,0 @@
-#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