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

[SVN r7754]

development/boost/iterator_concepts.hpp

@@ -1,282 +0,0 @@
-#ifndef BOOST_ITERATOR_CONCEPTS_HPP
-#define BOOST_ITERATOR_CONCEPTS_HPP
-
-#include <boost/concept_check.hpp>
-#include <boost/iterator_traits.hpp>
-
-namespace boost_concepts {
-  // Used a different namespace here (instead of "boost") so that the
-  // concept descriptions do not take for granted the names in
-  // namespace boost.
-
-
-  //===========================================================================
-
-  template <typename Iterator>
-  class ReadableIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::return_category 
-      return_category;
-
-    void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
-      boost::function_requires< boost::DefaultConstructibleConcept<Iterator> >();
-      
-      boost::function_requires< 
-        boost::ConvertibleConcept<return_category, boost::readable_iterator_tag> >();
-
-      reference r = *i; // or perhaps read(x)
-      value_type v(r);
-      boost::ignore_unused_variable_warning(v);
-    }
-    Iterator i;
-  };
-  
-  template <typename Iterator, typename ValueType>
-  class WritableIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::return_category 
-      return_category;
-
-    void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
-      boost::function_requires< boost::DefaultConstructibleConcept<Iterator> >();
-      
-      boost::function_requires< 
-        boost::ConvertibleConcept<return_category, boost::writable_iterator_tag> >();
-
-      *i = v; // an alternative could be something like write(x, v)
-    }
-    ValueType v;
-    Iterator i;
-  };
-  
-  template <typename Iterator>
-  class ConstantLvalueIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::return_category 
-      return_category;
-
-    void constraints() {
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-      
-      boost::function_requires< 
-        boost::ConvertibleConcept<return_category, 
-          boost::constant_lvalue_iterator_tag> >();
-
-      typedef typename boost::require_same<reference, const value_type&>::type req;
-
-      reference v = *i;
-      boost::ignore_unused_variable_warning(v);
-    }
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class MutableLvalueIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::return_category 
-      return_category;
-
-    void constraints() {
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-      boost::function_requires< WritableIteratorConcept<Iterator, value_type> >();
-      
-      boost::function_requires< 
-        boost::ConvertibleConcept<return_category, 
-          boost::constant_lvalue_iterator_tag> >();
-
-      typedef typename boost::require_same<reference, value_type&>::type req;
-
-      reference v = *i;
-      boost::ignore_unused_variable_warning(v);
-    }
-    Iterator i;
-  };
-  
-  //===========================================================================
-
-  template <typename Iterator>
-  class SinglePassIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::motion_category 
-      motion_category;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
-      boost::function_requires< boost::DefaultConstructibleConcept<Iterator> >();
-
-      boost::function_requires< 
-        boost::ConvertibleConcept<motion_category, 
-          boost::single_pass_iterator_tag> >();
-      
-      // difference_type must be a signed integral type
-
-      ++i;
-      (void)i++;
-    }
-    
-    Iterator i;
-  };
-  
-  template <typename Iterator>
-  class ForwardIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::motion_category 
-      motion_category;
-
-    void constraints() {
-      boost::function_requires< SinglePassIteratorConcept<Iterator> >();
-
-      boost::function_requires< 
-        boost::ConvertibleConcept<motion_category, 
-          boost::forward_iterator_tag> >();
-    }
-  };
-  
-  template <typename Iterator>
-  class BidirectionalIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::motion_category 
-      motion_category;
-
-    void constraints() {
-      boost::function_requires< ForwardIteratorConcept<Iterator> >();
-      
-      boost::function_requires< 
-        boost::ConvertibleConcept<motion_category, 
-          boost::bidirectional_iterator_tag> >();
-
-      --i;
-      (void)i--;
-    }
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class RandomAccessIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::motion_category 
-      motion_category;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< BidirectionalIteratorConcept<Iterator> >();
-
-      boost::function_requires< 
-        boost::ConvertibleConcept<motion_category, 
-          boost::random_access_iterator_tag> >();
-
-      i += n;
-      i = i + n;
-      i = n + i;
-      i -= n;
-      i = i - n;
-      n = i - j;
-    }
-    difference_type n;
-    Iterator i, j;
-  };
-
-  //===========================================================================
-
-  template <typename Iterator>
-  class ReadableRandomAccessIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-      
-      reference r = i[n];
-      value_type v(r);
-      boost::ignore_unused_variable_warning(v);
-    }
-    difference_type n;
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class WritableRandomAccessIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
-      boost::function_requires< WritableIteratorConcept<Iterator, value_type> >();
-
-      i[n] = v;
-      boost::ignore_unused_variable_warning(v);
-    }
-    difference_type n;
-    value_type v;
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class ConstantLvalueRandomAccessIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-
-      typedef typename boost::require_same<reference, const value_type&>::type req;
-
-      reference v = i[n];
-      boost::ignore_unused_variable_warning(v);
-    }
-    difference_type n;
-    value_type v;
-    Iterator i;
-  };
-  
-  template <typename Iterator>
-  class MutableLvalueRandomAccessIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
-      boost::function_requires< WritableIteratorConcept<Iterator, value_type> >();
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-
-      typedef typename boost::require_same<reference, value_type&>::type req;
-
-      reference v = i[n];
-      boost::ignore_unused_variable_warning(v);
-    }
-    difference_type n;
-    value_type v;
-    Iterator i;
-  };
-  
-} // namespace boost_concepts
-
-
-#endif // BOOST_ITERATOR_CONCEPTS_HPP

development/boost/iterator_traits.hpp

@@ -1,60 +0,0 @@
-#ifndef BOOST_ITERATOR_TRAITS_HPP
-#define BOOST_ITERATOR_TRAITS_HPP
-
-#include <boost/config.hpp>
-#include <boost/type_traits.hpp>
-
-namespace boost {
-  
-  template <typename Iterator>
-  struct iterator_traits {
-    typedef typename Iterator::value_type value_type;
-    typedef typename Iterator::reference reference;
-    typedef typename Iterator::pointer pointer;
-    typedef typename Iterator::difference_type difference_type;
-    typedef typename Iterator::return_category return_category;
-    typedef typename Iterator::motion_category motion_category;
-  };
-
-  // Motion Categories
-  struct single_pass_iterator_tag { };
-  struct forward_iterator_tag : public single_pass_iterator_tag { };
-  struct bidirectional_iterator_tag : public forward_iterator_tag { };
-  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
-  
-  // Return Type Categories
-  struct readable_iterator_tag { };
-  struct writable_iterator_tag { };
-  struct mutable_lvalue_iterator_tag : virtual public writable_iterator_tag,
-    virtual public readable_iterator_tag { };
-  struct constant_lvalue_iterator_tag : public readable_iterator_tag { };
-  
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-  namespace detail {
-    template <bool IsConst>
-    struct pointer_return_category {
-      typedef constant_lvalue_iterator_tag type;
-    };
-    template <>
-    struct pointer_return_category<false> {
-      typedef mutable_lvalue_iterator_tag type;
-    };
-  } // namespace detail
-
-  template <typename T>
-  struct iterator_traits<T*> {
-    typedef T value_type;
-    typedef T& reference;
-    typedef T* pointer;
-    typedef std::ptrdiff_t difference_type;
-    typedef typename detail::pointer_return_category<is_const<T>::value>::type
-      return_category;
-    typedef random_access_iterator_tag motion_category;
-  };
-
-#endif
-
-} // namespace boost
-
-#endif // BOOST_ITERATOR_TRAITS_HPP

development/libs/iterator/concept_tests.cpp

@@ -1,13 +0,0 @@
-#include <boost/iterator_concepts.hpp>
-
-int
-main()
-{
-  boost::function_requires< 
-    boost_concepts::MutableLvalueRandomAccessIteratorConcept<int*> >();
-
-  boost::function_requires< 
-    boost_concepts::ConstantLvalueRandomAccessIteratorConcept<const int*> >();
-
-  return 0;
-}

include/boost/counting_iterator.hpp

@@ -1,215 +0,0 @@
-// (C) Copyright David Abrahams and Jeremy Siek 2000-2001. Permission to copy,
-// use, modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided "as is"
-// without express or implied warranty, and with no claim as to its suitability
-// for any purpose.
-//
-// See http://www.boost.org for most recent version including documentation.
-//
-// Supplies:
-//
-//   template <class Incrementable> class counting_iterator_traits;
-//   template <class Incrementable> class counting_iterator_policies;
-//
-//     Iterator traits and policies for adapted iterators whose dereferenced
-//     value progresses through consecutive values of Incrementable when the
-//     iterator is derferenced.
-//
-//   template <class Incrementable> struct counting_iterator_generator;
-//
-//     A "type generator" whose nested type "type" is a counting iterator as
-//     described above.
-//
-//   template <class Incrementable>
-//     typename counting_iterator_generator<Incrementable>::type
-//     make_counting_iterator(Incrementable);
-//
-//     A function which produces an adapted counting iterator over values of
-//     Incrementable.
-// 
-// Revision History
-// 14 Feb 2001  Removed unnecessary typedefs from counting_iterator_traits
-//              (Jeremy Siek)
-// 11 Feb 2001  Use BOOST_STATIC_CONSTANT (Dave Abrahams)
-// 11 Feb 2001  Clean up after John Maddocks's (finally effective!) Borland
-//              fixes (David Abrahams).
-// 10 Feb 2001  Use new iterator_adaptor<> interface (David Abrahams)
-// 10 Feb 2001  Rolled in supposed Borland fixes from John Maddock, but not
-//              seeing any improvement yet (David Abrahams)
-// 09 Feb 2001  Factored out is_numeric computation. Borland still
-//              unhappy :( (David Abrahams)
-// 08 Feb 2001  Beginning of a failed attempt to appease Borland
-//              (David Abrahams)
-// 07 Feb 2001  rename counting_iterator() -> make_counting_iterator()
-//              (David Abrahams)        
-// 04 Feb 2001  Added counting_iterator_generator; updated comments
-//              (David Abrahams)
-// 24 Jan 2001  initial revision, based on Jeremy Siek's
-//              boost/pending/integer_range.hpp (David Abrahams)
-
-#ifndef BOOST_COUNTING_ITERATOR_HPP_DWA20000119
-# define BOOST_COUNTING_ITERATOR_HPP_DWA20000119
-
-# include <boost/config.hpp>
-# include <boost/detail/iterator.hpp>
-# include <boost/iterator_adaptors.hpp>
-# include <boost/type_traits.hpp>
-# include <boost/detail/numeric_traits.hpp>
-# include <boost/static_assert.hpp>
-# ifndef BOOST_NO_LIMITS
-#  include <limits>
-# endif
-
-namespace boost {
-
-namespace detail {
-
-  // Template class counting_iterator_traits_select -- choose an
-  // iterator_category and difference_type for a counting_iterator at
-  // compile-time based on whether or not it wraps an integer or an iterator,
-  // using "poor man's partial specialization".
-  template <bool is_integer> struct counting_iterator_traits_select;
-
-  // Incrementable is an iterator type
-  template <>
-  struct counting_iterator_traits_select<false>
-  {
-      template <class Incrementable>
-      struct traits
-      {
-       private:
-          typedef boost::detail::iterator_traits<Incrementable> x;
-       public:
-          typedef typename x::iterator_category iterator_category;
-          typedef typename x::difference_type difference_type;
-      };
-  };
-
-  // Incrementable is a numeric type
-  template <>
-  struct counting_iterator_traits_select<true>
-  {
-      template <class Incrementable>
-      struct traits
-      {
-          typedef typename
-            boost::detail::numeric_traits<Incrementable>::difference_type
-          difference_type;
-          typedef std::random_access_iterator_tag iterator_category;
-      };
-  };
-
-  // Template class distance_policy_select -- choose a policy for computing the
-  // distance between counting_iterators at compile-time based on whether or not
-  // the iterator wraps an integer or an iterator, using "poor man's partial
-  // specialization".
-
-  template <bool is_integer> struct distance_policy_select;
-
-  // A policy for wrapped iterators
-  template <>
-  struct distance_policy_select<false>
-  {
-      template <class Distance, class Incrementable>
-      struct policy {
-          static Distance distance(Incrementable x, Incrementable y)
-              { return boost::detail::distance(x, y); }
-      };
-  };
-
-  // A policy for wrapped numbers
-  template <>
-  struct distance_policy_select<true>
-  {
-      template <class Distance, class Incrementable>
-      struct policy {
-          static Distance distance(Incrementable x, Incrementable y)
-              { return numeric_distance(x, y); }
-      };
-  };
-
-  // Try to detect numeric types at compile time in ways compatible with the
-  // limitations of the compiler and library.
-  template <class T>
-  struct is_numeric {
-    // For a while, this wasn't true, but we rely on it below. This is a regression assert.
-    BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
-# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
-# else
-#  if !defined(__BORLANDC__)
-    BOOST_STATIC_CONSTANT(bool, value = (
-        boost::is_convertible<int,T>::value && boost::is_convertible<T,int>::value));
-#  else
-    BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
-#  endif
-# endif
-  };
-
-  // Compute the distance over arbitrary numeric and/or iterator types
-  template <class Distance, class Incrementable>
-  Distance any_distance(Incrementable start, Incrementable finish, Distance* = 0)
-  {
-    
-      return distance_policy_select<(
-          is_numeric<Incrementable>::value)>::template
-          policy<Distance, Incrementable>::distance(start, finish);
-  }
-  
-} // namespace detail
-
-template <class Incrementable>
-struct counting_iterator_traits {
- private:
-    typedef ::boost::detail::counting_iterator_traits_select<(
-        ::boost::detail::is_numeric<Incrementable>::value
-        )> binder;
-    typedef typename binder::template traits<Incrementable> traits;
- public:
-    typedef typename traits::difference_type difference_type;
-    typedef typename traits::iterator_category iterator_category;
-};
-
-template <class Incrementable>
-struct counting_iterator_policies : public default_iterator_policies
-{
-    const Incrementable& dereference(type<const Incrementable&>, const Incrementable& i) const
-        { return i; }
-
-    template <class Difference, class Iterator1, class Iterator2>
-    Difference distance(type<Difference>, const Iterator1& x,
-                        const Iterator2& y) const
-    {
-        return boost::detail::any_distance<Difference>(x, y);//,(Difference*)());
-    }
-};
-
-// A type generator for counting iterators
-template <class Incrementable>
-struct counting_iterator_generator
-{
-    typedef counting_iterator_traits<Incrementable> traits;
-    
-    typedef iterator_adaptor<Incrementable,
-        counting_iterator_policies<Incrementable>,
-        Incrementable,
-        const Incrementable&,
-        const Incrementable*,
-        typename traits::iterator_category,
-        typename traits::difference_type
-    > type;
-};
-
-// Manufacture a counting iterator for an arbitrary incrementable type
-template <class Incrementable>
-inline typename counting_iterator_generator<Incrementable>::type
-make_counting_iterator(Incrementable x)
-{
-  typedef typename counting_iterator_generator<Incrementable>::type result_t;
-  return result_t(x);
-}
-
-
-} // namespace boost
-
-#endif // BOOST_COUNTING_ITERATOR_HPP_DWA20000119

include/boost/function_output_iterator.hpp

@@ -1,55 +0,0 @@
-// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-// Revision History:
-
-// 27 Feb 2001   Jeremy Siek
-//      Initial checkin.
-
-#ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
-#define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
-
-#include <iterator>
-
-namespace boost {
-
-  template <class UnaryFunction>
-  class function_output_iterator {
-    typedef function_output_iterator self;
-  public:
-    typedef std::output_iterator_tag iterator_category;
-    typedef void                value_type;
-    typedef void                difference_type;
-    typedef void                pointer;
-    typedef void                reference;
-
-    explicit function_output_iterator(const UnaryFunction& f = UnaryFunction())
-      : m_f(f) {}
-
-    struct output_proxy {
-      output_proxy(UnaryFunction& f) : m_f(f) { }
-      template <class T> output_proxy& operator=(const T& value) {
-        m_f(value); 
-        return *this; 
-      }
-      UnaryFunction& m_f;
-    };
-    output_proxy operator*() { return output_proxy(m_f); }
-    self& operator++() { return *this; } 
-    self& operator++(int) { return *this; }
-  private:
-    UnaryFunction m_f;
-  };
-
-  template <class UnaryFunction>
-  inline function_output_iterator<UnaryFunction>
-  make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
-    return function_output_iterator<UnaryFunction>(f);
-  }
-
-} // namespace boost
-
-#endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP

include/boost/half_open_range.hpp

@@ -1,426 +0,0 @@
-// (C) Copyright Jeremy Siek and David Abrahams 2000-2001. Permission to copy,
-// use, modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided "as is"
-// without express or implied warranty, and with no claim as to its suitability
-// for any purpose.
-//
-// Revision History:
-// 11 Feb 2001  Use new iterator_adaptor interface, Fixes for Borland.
-//              (Dave Abrahams)
-// 04 Feb 2001  Support for user-defined iterator categories (Dave Abrahams)
-// 30 Jan 2001  Initial Checkin (Dave Abrahams)
-
-#ifndef BOOST_HALF_OPEN_RANGE_HPP_
-# define BOOST_HALF_OPEN_RANGE_HPP_
-
-# include <boost/counting_iterator.hpp>
-# include <functional>
-# include <cassert>
-# include <boost/operators.hpp>
-# include <string>
-# include <stdexcept>
-# include <iterator>
-
-namespace boost {
-
-namespace detail {
-
-  // Template class choose_finish -- allows us to maintain the invariant that
-  // start() <= finish() on half_open_range specializations that support random
-  // access.
-#ifdef __MWERKS__
-  template <class T>
-  const T& choose_finish(const T&, const T& finish, std::input_iterator_tag)
-  {
-      return finish;
-  }
-
-  template <class T>
-  const T& choose_finish(const T&, const T& finish, std::output_iterator_tag)
-  {
-      return finish;
-  }
-
-  template <class T>
-  const T& choose_finish(const T& start, const T& finish, std::random_access_iterator_tag)
-  {
-      return finish < start ? start : finish;
-  }
-#else
-  template <bool is_random_access> struct finish_chooser;
-
-  template <>
-  struct finish_chooser<false>
-  {
-      template <class T>
-      struct rebind
-      {
-          static T choose(const T&, const T& finish)
-              { return finish; }
-      };
-  };
-
-  template <>
-  struct finish_chooser<true>
-  {
-      template <class T>
-      struct rebind
-      {
-          static T choose(const T& start, const T& finish)
-              { return finish < start ? start : finish; }
-      };
-  };
-
-  template <class Category, class Incrementable>
-  struct choose_finish
-  {
-      static const Incrementable choose(const Incrementable& start, const Incrementable& finish)
-      {
-          return finish_chooser<(
-              ::boost::is_convertible<Category*,std::random_access_iterator_tag*>::value
-              )>::template rebind<Incrementable>::choose(start, finish);
-      }
-  };
-#endif
-}
-
-template <class Incrementable>
-struct half_open_range
-{
-    typedef typename counting_iterator_generator<Incrementable>::type iterator;
-
- private: // utility type definitions
-    // Using iter_t prevents compiler confusion with boost::iterator
-    typedef typename counting_iterator_generator<Incrementable>::type iter_t;
-
-    typedef std::less<Incrementable> less_value;
-    typedef typename iter_t::iterator_category category;
-    typedef half_open_range<Incrementable> self;
-
- public:
-    typedef iter_t const_iterator;
-    typedef typename counting_iterator_traits<Incrementable>::value_type value_type;
-    typedef typename counting_iterator_traits<Incrementable>::difference_type difference_type;
-    typedef typename counting_iterator_traits<Incrementable>::reference reference;
-    typedef typename counting_iterator_traits<Incrementable>::reference const_reference;
-    typedef typename counting_iterator_traits<Incrementable>::pointer pointer;
-    typedef typename counting_iterator_traits<Incrementable>::pointer const_pointer;
-    
-    // It would be nice to select an unsigned type, but this is appropriate
-    // since the library makes an attempt to select a difference_type which can
-    // hold the difference between any two iterators.
-    typedef typename counting_iterator_traits<Incrementable>::difference_type size_type;
-
-    half_open_range(Incrementable start, Incrementable finish)
-        : m_start(start),
-          m_finish(
-#ifndef __MWERKS__
-            detail::choose_finish<category,Incrementable>::choose(start, finish)
-#else
-            detail::choose_finish(start, finish, category())
-#endif
-              )
-        {}
-
-    // Implicit conversion from std::pair<Incrementable,Incrementable> allows us
-    // to accept the results of std::equal_range(), for example.
-    half_open_range(const std::pair<Incrementable,Incrementable>& x)
-        : m_start(x.first),
-          m_finish(
-#ifndef __MWERKS__
-              detail::choose_finish<category,Incrementable>::choose(x.first, x.second)
-#else
-            detail::choose_finish(x.first, x.second, category())
-#endif
-              )
-        {}
-
-    half_open_range& operator=(const self& x)
-    {
-        m_start = x.m_start;
-        m_finish = x.m_finish;
-        return *this;
-    }
-    
-    half_open_range& operator=(const std::pair<Incrementable,Incrementable>& x)
-    {
-        m_start = x.first;
-        m_finish =
-#ifndef __MWERKS__
-            detail::choose_finish<category,Incrementable>::choose(x.first, x.second);
-#else
-            detail::choose_finish(x.first, x.second, category();
-#endif
-    }
-        
-    iterator begin() const { return iterator(m_start); }
-    iterator end() const { return iterator(m_finish); }
-    
-    Incrementable front() const { assert(!this->empty()); return m_start; }
-    Incrementable back() const { assert(!this->empty()); return boost::prior(m_finish); }
-                                     
-    Incrementable start() const { return m_start; }
-    Incrementable finish() const { return m_finish; }
-    
-    size_type size() const { return boost::detail::distance(begin(), end()); }
-
-    bool empty() const
-    {
-        return m_finish == m_start;
-    }
-
-    void swap(half_open_range& x) {
-        std::swap(m_start, x.m_start);
-        std::swap(m_finish, x.m_finish);
-    }
-    
- public: // functions requiring random access elements
-    
-    // REQUIRES: x is reachable from this->front()
-    bool contains(const value_type& x) const
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        return !less_value()(x, m_start) && less_value()(x, m_finish);
-    }
-
-    bool contains(const half_open_range& x) const
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        return x.empty() || !less_value()(x.m_start, m_start) && !less_value()(m_finish, x.m_finish);
-    }
-
-    bool intersects(const half_open_range& x) const
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        return less_value()(
-            less_value()(this->m_start, x.m_start) ? x.m_start : this->m_start,
-            less_value()(this->m_finish, x.m_finish) ? this->m_finish : x.m_finish);
-    }
-
-    half_open_range& operator&=(const half_open_range& x)
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        
-        if (less_value()(this->m_start, x.m_start))
-            this->m_start = x.m_start;
-        
-        if (less_value()(x.m_finish, this->m_finish))
-            this->m_finish = x.m_finish;
-
-        if (less_value()(this->m_finish, this->m_start))
-            this->m_start = this->m_finish;
-
-        return *this;
-    }
-
-    half_open_range& operator|=(const half_open_range& x)
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-
-        if (!x.empty())
-        {
-            if (this->empty())
-            {
-                *this = x;
-            }
-            else
-            {
-                if (less_value()(x.m_start, this->m_start))
-                    this->m_start = x.m_start;
-        
-                if (less_value()(this->m_finish, x.m_finish))
-                    this->m_finish = x.m_finish;
-            }
-        }
-        return *this;
-    }
-
-    // REQUIRES: x is reachable from this->front()
-    const_iterator find(const value_type& x) const
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        
-        return const_iterator(this->contains(x) ? x : m_finish);
-    }
-
-    // REQUIRES: index >= 0 && index < size()
-    value_type operator[](size_type index) const
-    {
-        assert(index >= 0 && index < size());
-        return m_start + index;
-    }
-    
-    value_type at(size_type index) const
-    {
-        if (index < 0 || index >= size())
-            throw std::out_of_range(std::string("half_open_range"));
-        return m_start + index;
-    }
-    
- private: // data members
-    Incrementable m_start, m_finish;
-};
-
-template <class Incrementable>
-half_open_range<Incrementable> operator|(
-    half_open_range<Incrementable> x,
-    const half_open_range<Incrementable>& y)
-{
-    return x |= y;
-}
-
-template <class Incrementable>
-half_open_range<Incrementable> operator&(
-    half_open_range<Incrementable> x,
-    const half_open_range<Incrementable>& y)
-{
-    return x &= y;
-}
-
-template <class Incrementable>
-inline bool operator==(
-    const half_open_range<Incrementable>& x,
-    const half_open_range<Incrementable>& y)
-{
-    const bool y_empty = y.empty();
-    return x.empty() ? y_empty : !y_empty && x.start() == y.start() && x.finish() == y.finish();
-}
-
-template <class Incrementable>
-inline bool operator!=(
-    const half_open_range<Incrementable>& x,
-    const half_open_range<Incrementable>& y)
-{
-    return !(x == y);
-}
-
-template <class Incrementable>
-inline half_open_range<Incrementable>
-make_half_open_range(Incrementable first, Incrementable last)
-{
-  return half_open_range<Incrementable>(first, last);
-}
-
-template <class Incrementable>
-bool intersects(
-    const half_open_range<Incrementable>& x,
-    const half_open_range<Incrementable>& y)
-{
-    return x.intersects(y);
-}
-    
-template <class Incrementable>
-bool contains(
-    const half_open_range<Incrementable>& x,
-    const half_open_range<Incrementable>& y)
-{
-    return x.contains(y);
-}
-    
-} // namespace boost
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace std {
-template <class Incrementable> struct less<boost::half_open_range<Incrementable> >
-        : binary_function<
-            boost::half_open_range<Incrementable>,
-            boost::half_open_range<Incrementable>,bool>
-{
-    bool operator()(
-        const boost::half_open_range<Incrementable>& x,
-        const boost::half_open_range<Incrementable>& y) const
-    {
-        less<Incrementable> cmp;
-        return !y.empty() && (
-            cmp(x.start(), y.start())
-            || !cmp(y.start(), x.start())
-               && cmp(x.finish(), y.finish()));
-    }
-};
-
-template <class Incrementable> struct less_equal<boost::half_open_range<Incrementable> >
-        : binary_function<
-            boost::half_open_range<Incrementable>,
-            boost::half_open_range<Incrementable>,bool>
-{
-    bool operator()(
-        const boost::half_open_range<Incrementable>& x,
-        const boost::half_open_range<Incrementable>& y) const
-    {
-        typedef boost::half_open_range<Incrementable> range;
-        less<range> cmp;
-        return !cmp(y,x);
-    }
-};
-template <class Incrementable> struct greater<boost::half_open_range<Incrementable> >
-        : binary_function<
-            boost::half_open_range<Incrementable>,
-            boost::half_open_range<Incrementable>,bool>
-{
-    bool operator()(
-        const boost::half_open_range<Incrementable>& x,
-        const boost::half_open_range<Incrementable>& y) const
-    {
-        typedef boost::half_open_range<Incrementable> range;
-        less<range> cmp;
-        return cmp(y,x);
-    }
-};
-
-template <class Incrementable> struct greater_equal<boost::half_open_range<Incrementable> >
-        : binary_function<
-            boost::half_open_range<Incrementable>,
-            boost::half_open_range<Incrementable>,bool>
-{
-    bool operator()(
-        const boost::half_open_range<Incrementable>& x,
-        const boost::half_open_range<Incrementable>& y) const
-    {
-        typedef boost::half_open_range<Incrementable> range;
-        less<range> cmp;
-        return !cmp(x,y);
-    }
-};
-} // namespace std
-
-#else
-
-namespace boost {
-// Can't partially specialize std::less et al, so we must provide the operators
-template <class Incrementable>
-bool operator<(const half_open_range<Incrementable>& x,
-               const half_open_range<Incrementable>& y)
-{
-    return !y.empty() && (
-        x.empty() || std::less<Incrementable>()(x.start(), y.start())
-        || !std::less<Incrementable>()(y.start(), x.start())
-                && std::less<Incrementable>()(x.finish(), y.finish()));
-}
-
-template <class Incrementable>
-bool operator>(const half_open_range<Incrementable>& x,
-               const half_open_range<Incrementable>& y)
-{
-    return y < x;
-}
-
-template <class Incrementable>
-bool operator<=(const half_open_range<Incrementable>& x,
-               const half_open_range<Incrementable>& y)
-{
-    return !(y < x);
-}
-
-template <class Incrementable>
-bool operator>=(const half_open_range<Incrementable>& x,
-               const half_open_range<Incrementable>& y)
-{
-    return !(x < y);
-}
-} // namespace boost
-
-#endif
-    
-
-#endif // BOOST_HALF_OPEN_RANGE_HPP_

include/boost/iterator.hpp

@@ -1,4 +1,4 @@
-//  interator.hpp workarounds for non-conforming standard libraries  ---------//
+//  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
@@ -8,7 +8,6 @@
 //  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
-//  12 Jan 01 added <cstddef> for std::ptrdiff_t (Jens Maurer)
 //  28 Jun 00 Workarounds to deal with known MSVC bugs (David Abrahams)
 //  26 Jun 00 Initial version (Jeremy Siek)
 
@@ -16,7 +15,6 @@
 #define BOOST_ITERATOR_HPP
 
 #include <iterator>
-#include <cstddef>           // std::ptrdiff_t
 #include <boost/config.hpp>
 
 namespace boost

include/boost/pending/detail/int_iterator.hpp

@@ -29,7 +29,7 @@ public:
   typedef IntT value_type;
   typedef IntT& reference;
   typedef IntT* pointer;
-  typedef std::ptrdiff_t difference_type;
+  typedef ptrdiff_t difference_type;
 
   inline int_iterator() : _i(0) { }
   inline int_iterator(IntT i) : _i(i) { }
@@ -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 += n; return t; }
+  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; }
@@ -50,17 +50,10 @@ 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

@@ -1,28 +1,52 @@
-// (C) Copyright David Abrahams and Jeremy Siek 2000-2001. Permission to copy,
-// use, modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided "as is"
-// without express or implied warranty, and with no claim as to its suitability
-// for any purpose.
+// (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.
 //
-// Revision History:
-// 04 Jan 2001  Factored counting_iterator stuff into
-//              boost/counting_iterator.hpp (David Abrahams)
+// (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_
 
-#include <boost/config.hpp>
-#include <boost/counting_iterator.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 {
-    typedef typename counting_iterator_generator<IntegerType>::type iterator;
-
+#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;
@@ -47,13 +71,6 @@ 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
 
 #endif // BOOST_INTEGER_RANGE_HPP_

include/boost/pending/iterator_adaptors.hpp

@@ -1 +1,510 @@
-#include <boost/iterator_adaptors.hpp>
+// (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,28 +1,16 @@
 #ifndef BOOST_ITERATOR_TESTS_HPP
-# define 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.
-//
-// Revision History:
-// 08 Feb 2001  Fixed bidirectional iterator test so that
-//              --i is no longer a precondition.
-//              (Jeremy Siek)
-// 04 Feb 2001  Added lvalue test, corrected preconditions
-//              (David Abrahams)
 
-# include <iterator>
-# include <assert.h>
-# include <boost/type_traits.hpp>
-# include <boost/static_assert.hpp>
-# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
+#include <assert.h>
 
 namespace boost {
 
   // use this for the value type
 struct dummyT { 
   dummyT() { }
-  dummyT(detail::dummy_constructor) { }
   dummyT(int x) : m_x(x) { }
   int foo() const { return m_x; } 
   bool operator==(const dummyT& d) const { return m_x == d.m_x; }
@@ -34,7 +22,7 @@ struct dummyT {
 // TrivialIterator. 
 // Preconditions: i != j, *i == val
 template <class Iterator, class T>
-void trivial_iterator_test(const Iterator i, const Iterator j, T val)
+void trivial_iterator_test(Iterator i, Iterator j, T val)
 {
   Iterator k;
   assert(i == i);
@@ -63,7 +51,7 @@ void trivial_iterator_test(const Iterator i, const Iterator j, T val)
 
 // Preconditions: i != j
 template <class Iterator, class T>
-void mutable_trivial_iterator_test(const Iterator i, const Iterator j, T val)
+void mutable_trivial_iterator_test(Iterator i, Iterator j, T val)
 {
   *i = val;
   trivial_iterator_test(i, j, val);
@@ -94,47 +82,17 @@ void input_iterator_test(Iterator i, T v1, T v2)
 
 // how to test output iterator?
 
-
-template <bool is_pointer> struct lvalue_test
-{
-    template <class Iterator> static void check(Iterator)
-    {
-# ifndef BOOST_NO_STD_ITERATOR_TRAITS
-        typedef typename std::iterator_traits<Iterator>::reference reference;
-        typedef typename std::iterator_traits<Iterator>::value_type value_type;
-# else
-        typedef typename Iterator::reference reference;
-        typedef typename Iterator::value_type value_type;
-# endif
-        BOOST_STATIC_ASSERT(boost::is_reference<reference>::value);
-        BOOST_STATIC_ASSERT((boost::is_same<reference,value_type&>::value
-                             || boost::is_same<reference,const value_type&>::value
-            ));
-    }
-};
-
-# ifdef BOOST_NO_STD_ITERATOR_TRAITS
-template <> struct lvalue_test<true> {
-    template <class T> static void check(T) {}
-};
-#endif
-
 template <class Iterator, class T>
 void forward_iterator_test(Iterator i, T v1, T v2) 
 {
   input_iterator_test(i, v1, v2);
-
- // borland doesn't allow non-type template parameters
-# if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
-  lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);
-#endif
 }
 
 // Preconditions: *i == v1, *++i == v2
 template <class Iterator, class T>
 void bidirectional_iterator_test(Iterator i, T v1, T v2)
 {
-  forward_iterator_test(i, v1, v2);
+  input_iterator_test(i, v1, v2);
   ++i;
 
   Iterator i1 = i, i2 = i;
@@ -148,8 +106,8 @@ void bidirectional_iterator_test(Iterator i, T v1, T v2)
   --i;
   assert(i == i1);
   assert(i == i2);
-  ++i1;
-  ++i2;
+  --i1;
+  --i2;
 
   trivial_iterator_test(i, i1, v1);
   trivial_iterator_test(i, i2, v1);
@@ -162,7 +120,7 @@ template <class Iterator, class TrueVals>
 void random_access_iterator_test(Iterator i, int N, TrueVals vals)
 {
   bidirectional_iterator_test(i, vals[0], vals[1]);
-  const Iterator j = i;
+  Iterator j = i;
   int c;
 
   for (c = 0; c < N-1; ++c) {
@@ -183,8 +141,7 @@ 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]);
-    Iterator q = k - c; 
-    assert(*i == *q);
+    assert(*i == *(k - c));
     assert(i > j);
     assert(i >= j);
     assert(j <= i);