Moved pointer parameter

[SVN r9348]

include/boost/counting_iterator.hpp

@@ -194,9 +194,9 @@ struct counting_iterator_generator
         counting_iterator_policies<Incrementable>,
         Incrementable,
         const Incrementable&,
-        const Incrementable*,
         typename traits::iterator_category,
-        typename traits::difference_type
+        typename traits::difference_type,
+        const Incrementable*
     > type;
 };
 

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,60 +0,0 @@
-//  interator.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
-//  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)
-
-#ifndef BOOST_ITERATOR_HPP
-#define BOOST_ITERATOR_HPP
-
-#include <iterator>
-#include <cstddef>           // std::ptrdiff_t
-#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/iterator_adaptors.hpp

@@ -12,8 +12,6 @@
 //
 // Revision History:
 
-// 08 Mar 2001   Jeremy Siek
-//      Added support for optional named template parameters.
 // 19 Feb 2001   David Abrahams
 //      Rolled back reverse_iterator_pair_generator again, as it doesn't
 //      save typing on a conforming compiler.
@@ -106,7 +104,6 @@
 # include <boost/type_traits.hpp>
 # include <boost/detail/iterator.hpp>
 # include <boost/detail/select_type.hpp>
-# include <boost/detail/named_template_params.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
@@ -223,9 +220,6 @@ struct default_iterator_policies
     void initialize(Base&)
         { }
 
-    // The "type<Reference>" parameter is a portable mechanism for
-    // the iterator_adaptor class to tell this member function what
-    // the Reference type is, which is needed for the return type.
     template <class Reference, class Base>
     Reference dereference(type<Reference>, const Base& x) const
         { return *x; }
@@ -435,111 +429,8 @@ namespace detail {
        
    };
 # endif
-
-  //===========================================================================
-  // Specify the defaults for iterator_adaptor's template parameters
-  
-  struct default_value_type {
-    template <class Base, class Traits>
-    struct bind {
-      typedef typename boost::detail::iterator_traits<Base>::value_type type;
-    };
-  };
-  struct default_difference_type {
-    template <class Base, class Traits>
-    struct bind {
-      typedef typename boost::detail::iterator_traits<Base>::difference_type type;
-    };
-  };
-  struct default_iterator_category {
-    template <class Base, class Traits>
-    struct bind {
-      typedef typename boost::detail::iterator_traits<Base>::iterator_category type;
-    };
-  };
-  struct default_pointer {
-    template <class Base, class Traits>
-    struct bind {
-      typedef typename Traits::value_type Value;
-      typedef typename boost::detail::iterator_defaults<Base,Value>::pointer 
-	type;
-    };
-  };
-  struct default_reference {
-    template <class Base, class Traits>
-    struct bind {
-      typedef typename Traits::value_type Value;
-      typedef typename boost::detail::iterator_defaults<Base,Value>::reference 
-	type;
-    };
-  };
-
-  //===========================================================================
-  // Support for named template parameters
-
-#if !defined(__BORLANDC__)
-  // Borland C++ thinks the nested recursive inheritance here is illegal.
-
-  template <class V = default_argument, 
-            class R = default_argument, 
-            class P = default_argument,
-            class C = default_argument,
-            class D = default_argument>
-  struct iter_traits_gen : public named_template_param_base {
-    template <class T>
-    struct value_type : public iter_traits_gen<T,R,P,C,D> { };
-    template <class T>
-    struct reference : public iter_traits_gen<V,T,P,C,D> { };
-    template <class T>
-    struct pointer : public iter_traits_gen<V,R,T,C,D> { };
-    template <class T>
-    struct iterator_category : public iter_traits_gen<V,R,P,T,D>{};
-    template <class T>
-    struct difference_type : public iter_traits_gen<V,R,P,C,T> { };
-
-    typedef boost::iterator<C, V, D, P, R> traits;
-  };
-#endif
-
-  BOOST_NAMED_TEMPLATE_PARAM(value_type);
-  BOOST_NAMED_TEMPLATE_PARAM(reference);
-  BOOST_NAMED_TEMPLATE_PARAM(pointer);
-  BOOST_NAMED_TEMPLATE_PARAM(iterator_category);
-  BOOST_NAMED_TEMPLATE_PARAM(difference_type);
-
-  template <class Base, class Value, class Reference, class Pointer,
-            class Category, class Distance>
-  class iterator_adaptor_traits_gen
-  {
-    typedef boost::iterator<Category, Value, Distance, Pointer, Reference>
-      Traits0;
-
-    typedef typename get_value_type<Base, 
-        typename boost::remove_const<Value>::type, Traits0
-        >::type value_type;
-    typedef typename get_difference_type<Base, Distance, Traits0>::type
-      difference_type;
-    typedef typename get_iterator_category<Base, Category, Traits0>::type
-      iterator_category;
-
-    typedef boost::iterator<iterator_category, value_type, difference_type,
-      Pointer, Reference> Traits1;
-    
-    typedef typename get_pointer<Base, Pointer, Traits1>::type pointer;
-    typedef typename get_reference<Base, Reference, Traits1>::type reference;
-  public:
-    typedef boost::iterator<iterator_category, value_type, difference_type,
-      pointer, reference> type;
-  };
-  
 } // namespace detail
 
-
-#if !defined(__BORLANDC__)
-struct iterator_traits_generator
-  : public detail::iter_traits_gen<> { };
-#endif
-
 // This macro definition is only temporary in this file
 # if !defined(BOOST_MSVC)
 #  define BOOST_ARG_DEPENDENT_TYPENAME typename
@@ -547,8 +438,6 @@ struct iterator_traits_generator
 #  define BOOST_ARG_DEPENDENT_TYPENAME
 # endif
 
-template <class T> struct undefined;
-
 //============================================================================
 //iterator_adaptor - Adapts a generic piece of data as an iterator. Adaptation
 //      is especially easy if the data being adapted is itself an iterator
@@ -566,44 +455,41 @@ template <class T> struct undefined;
 //      particular, the result type of operator*(). If not supplied but
 //      Value is supplied, Value& is used. Otherwise
 //      iterator_traits<Base>::reference is used.
+//   Category - the iterator_category of the resulting iterator. If not
+//      supplied, iterator_traits<Base>::iterator_category is used.
+//
+//   Distance - the difference_type of the resulting iterator. If not
+//      supplied, iterator_traits<Base>::difference_type is used.
 //
 //   Pointer - the pointer type of the resulting iterator, and in
 //      particular, the result type of operator->(). If not
 //      supplied but Value is supplied, Value* is used. Otherwise
 //      iterator_traits<Base>::pointer is used.
 //
-//   Category - the iterator_category of the resulting iterator. If not
-//      supplied, iterator_traits<Base>::iterator_category is used.
-//
-//   Distance - the difference_type of the resulting iterator. If not
-//      supplied, iterator_traits<Base>::difference_type is used.
 template <class Base, class Policies, 
-    class Value = detail::default_argument,
-    class Reference = BOOST_ARG_DEPENDENT_TYPENAME detail::choose_default_argument<Value>::type,
-    class Pointer = BOOST_ARG_DEPENDENT_TYPENAME detail::choose_default_argument<Reference>::type,
-    class Category = BOOST_ARG_DEPENDENT_TYPENAME detail::choose_default_argument<Pointer>::type,
-    class Distance = BOOST_ARG_DEPENDENT_TYPENAME detail::choose_default_argument<Category>::type
+    class Value = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<Base>::value_type,
+    class Reference = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<Base,Value>::reference,
+    class Category = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<Base>::iterator_category,
+    class Distance = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<Base>::difference_type,
+    class Pointer = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<Base,Value>::pointer
          >
 struct iterator_adaptor :
 #ifdef BOOST_RELOPS_AMBIGUITY_BUG
     iterator_comparisons<
-          iterator_adaptor<Base,Policies,Value,Reference,Pointer,Category,Distance>,
-    typename detail::iterator_adaptor_traits_gen<Base,Value,Reference,Pointer,Category, Distance>::type
- >
-#else
-    detail::iterator_adaptor_traits_gen<Base,Value,Reference,Pointer,Category,Distance>::type
+          iterator_adaptor<Base,Policies,Value,Reference,Category,Distance,Pointer>,
+#endif
+    boost::iterator<Category,Value,Distance,Pointer,Reference>
+#ifdef BOOST_RELOPS_AMBIGUITY_BUG
+>
 #endif
 {
-    typedef iterator_adaptor<Base,Policies,Value,Reference,Pointer,Category,Distance> self;
+    typedef iterator_adaptor<Base,Policies,Value,Reference,Category,Distance,Pointer> self;
  public:
-    typedef typename detail::iterator_adaptor_traits_gen<Base,Value,Reference,Pointer,Category,Distance>::type Traits;
-
-    typedef typename Traits::difference_type difference_type;
-    typedef typename Traits::value_type value_type;
-    typedef typename Traits::pointer pointer;
-    typedef typename Traits::reference reference;
-    typedef typename Traits::iterator_category iterator_category;
-
+    typedef Distance difference_type;
+    typedef typename boost::remove_const<Value>::type value_type;
+    typedef Pointer pointer;
+    typedef Reference reference;
+    typedef Category iterator_category;
     typedef Base base_type;
     typedef Policies policies_type;
 
@@ -615,18 +501,14 @@ struct iterator_adaptor :
     // Iterators should satisfy one of the known categories
     BOOST_STATIC_ASSERT(is_input_or_output_iter);
 
-    // Iterators >= ForwardIterator must produce real references
-    // as required by the C++ standard requirements in Table 74.
+    // Iterators >= ForwardIterator must produce real references.
     BOOST_STATIC_CONSTANT(bool, forward_iter_with_real_reference =
            (!boost::is_convertible<iterator_category*,std::forward_iterator_tag*>::value
            || boost::is_same<reference,value_type&>::value
            || boost::is_same<reference,const value_type&>::value));
     
-#if !defined(BOOST_MSVC)
-    // This check gives incorrect results in iter_traits_gen_test.cpp
     BOOST_STATIC_ASSERT(forward_iter_with_real_reference);
-#endif
-
+    
  public:
     iterator_adaptor() { }
 
@@ -638,7 +520,7 @@ struct iterator_adaptor :
 
     template <class Iter2, class Value2, class Pointer2, class Reference2>
     iterator_adaptor (
-        const iterator_adaptor<Iter2,Policies,Value2,Reference2,Pointer2,Category,Distance>& src)
+        const iterator_adaptor<Iter2,Policies,Value2,Reference2,Category,Distance,Pointer2>& src)
             : m_iter_p(src.iter(), src.policies())
     {
         policies().initialize(iter());
@@ -661,9 +543,9 @@ struct iterator_adaptor :
 # pragma warning( disable : 4284 )
 #endif
 
-    typename boost::detail::operator_arrow_result_generator<iterator_category,value_type,pointer>::type
+    typename boost::detail::operator_arrow_result_generator<Category,value_type,Pointer>::type
     operator->() const
-        { return detail::operator_arrow(*this, iterator_category()); }
+        { return detail::operator_arrow(*this, Category()); }
 
 #ifdef _MSC_VER
 # pragma warning(pop)
@@ -706,7 +588,7 @@ struct iterator_adaptor :
 
     // Moved from global scope to avoid ambiguity with the operator-() which
     // subtracts iterators from one another.
-    self operator-(difference_type x) const
+    self operator-(Distance x) const
         { self result(*this); return result -= x; }
 private:
     compressed_pair<Base,Policies> m_iter_p;
@@ -719,102 +601,99 @@ public: // implementation details (too many compilers have trouble when these ar
     const Base& iter() const { return m_iter_p.first(); }
 };
 
-template <class Base, class Policies, class Value, class Reference, class Pointer,
-    class Category, class Distance1, class Distance2>
-iterator_adaptor<Base,Policies,Value,Reference,Pointer,Category,Distance1>
+template <class Base, class Policies, class Value, class Reference,
+    class Category, class Distance1, class Pointer, class Distance2>
+iterator_adaptor<Base,Policies,Value,Reference,Category,Distance1,Pointer>
 operator+(
-    iterator_adaptor<Base,Policies,Value,Reference,Pointer,Category,Distance1> p,
+    iterator_adaptor<Base,Policies,Value,Reference,Category,Distance1,Pointer> p,
     Distance2 x)
 {
     return p += x;
 }
 
-template <class Base, class Policies, class Value, class Reference, class Pointer,
-    class Category, class Distance1, class Distance2>
-iterator_adaptor<Base,Policies,Value,Reference,Pointer,Category,Distance1>
+template <class Base, class Policies, class Value, class Reference,
+    class Category, class Distance1, class Pointer, class Distance2>
+iterator_adaptor<Base,Policies,Value,Reference,Category,Distance1,Pointer>
 operator+(
     Distance2 x,
-    iterator_adaptor<Base,Policies,Value,Reference,Pointer,Category,Distance1> p)
+    iterator_adaptor<Base,Policies,Value,Reference,Category,Distance1,Pointer> p)
 {
     return p += x;
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
-    class Reference1, class Reference2, class Pointer1, class Pointer2, class Category,
-    class Distance>
-typename iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>::difference_type
-operator-(
-    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
-    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
+    class Reference1, class Reference2, class Category,
+    class Distance, class Pointer1, class Pointer2>
+Distance operator-(
+    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Category,Distance,Pointer1>& x,
+    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Category,Distance,Pointer2>& y)
 {
-  typedef typename iterator_adaptor<Iterator1,Policies,Value1,Reference1,
-    Pointer1,Category,Distance>::difference_type difference_type;
-  return x.policies().distance(type<difference_type>(), y.iter(), x.iter());
+    return x.policies().distance(type<Distance>(), y.iter(), x.iter());
 }
 
 #ifndef BOOST_RELOPS_AMBIGUITY_BUG
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
-    class Reference1, class Reference2, class Pointer1, class Pointer2,
-    class Category, class Distance>
+    class Reference1, class Reference2,
+    class Category, class Distance, class Pointer1, class Pointer2>
 inline bool 
 operator==(
-    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
-    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
+    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Category,Distance,Pointer1>& x,
+    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Category,Distance,Pointer2>& y)
 {
     return x.policies().equal(x.iter(), y.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
-    class Reference1, class Reference2, class Pointer1, class Pointer2,
-    class Category, class Distance>
+    class Reference1, class Reference2,
+    class Category, class Distance, class Pointer1, class Pointer2>
 inline bool 
 operator<(
-    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
-    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
+    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Category,Distance,Pointer1>& x,
+    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Category,Distance,Pointer2>& y)
 {
     return x.policies().less(x.iter(), y.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
-    class Reference1, class Reference2, class Pointer1, class Pointer2,
-    class Category, class Distance>
+    class Reference1, class Reference2,
+    class Category, class Distance, class Pointer1, class Pointer2>
 inline bool 
 operator>(
-    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
-    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
+    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Category,Distance,Pointer1>& x,
+    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Category,Distance,Pointer2>& y)
 { 
     return x.policies().less(y.iter(), x.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
-    class Reference1, class Reference2, class Pointer1, class Pointer2,
-    class Category, class Distance>
+    class Reference1, class Reference2,
+    class Category, class Distance, class Pointer1, class Pointer2>
 inline bool 
 operator>=(
-    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
-    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
+    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Category,Distance,Pointer1>& x,
+    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Category,Distance,Pointer2>& y)
 {
     return !x.policies().less(x.iter(), y.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
-    class Reference1, class Reference2, class Pointer1, class Pointer2,
-    class Category, class Distance>
+    class Reference1, class Reference2,
+    class Category, class Distance, class Pointer1, class Pointer2>
 inline bool 
 operator<=(
-    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
-    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
+    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Category,Distance,Pointer1>& x,
+    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Category,Distance,Pointer2>& y)
 {
     return !x.policies().less(y.iter(), x.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
-    class Reference1, class Reference2, class Pointer1, class Pointer2,
-    class Category, class Distance>
+    class Reference1, class Reference2,
+    class Category, class Distance, class Pointer1, class Pointer2>
 inline bool 
 operator!=(
-    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x, 
-    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
+    const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Category,Distance,Pointer1>& x, 
+    const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Category,Distance,Pointer2>& y)
 {
     return !x.policies().equal(x.iter(), y.iter());
 }
@@ -846,7 +725,7 @@ class transform_iterator_generator
 public:
     typedef iterator_adaptor<Iterator, 
       transform_iterator_policies<AdaptableUnaryFunction>,
-        value_type, value_type, value_type*, std::input_iterator_tag>
+        value_type, value_type, std::input_iterator_tag>
       type;
 };
 
@@ -903,8 +782,11 @@ template <class OuterIterator,      // Mutable or Immutable, does not matter
          >
 struct indirect_iterator_generator
 {
+ private:
+    typedef typename boost::detail::iterator_traits<OuterIterator>::difference_type difference_type;
+ public:
     typedef iterator_adaptor<OuterIterator,
-        indirect_iterator_policies,Value,Reference,Pointer,Category> type;
+        indirect_iterator_policies,Value,Reference,Category,difference_type,Pointer> type;
 };
 
 template <class OuterIterator,      // Mutable or Immutable, does not matter
@@ -912,18 +794,14 @@ template <class OuterIterator,      // Mutable or Immutable, does not matter
 #if !defined(BOOST_MSVC)
                 = BOOST_ARG_DEPENDENT_TYPENAME detail::value_type_of_value_type<OuterIterator>::type
 #endif
-          , class Reference = Value&
-          , class ConstReference = const Value&
           , class Category = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<OuterIterator>::iterator_category
-          , class Pointer = Value*
-          , class ConstPointer = const Value*
            >
 struct indirect_iterator_pair_generator
 {
   typedef typename indirect_iterator_generator<OuterIterator,
-    Value, Reference,Category,Pointer>::type iterator;
+    Value,Value&,Category,Value*>::type iterator;
   typedef typename indirect_iterator_generator<OuterIterator,
-    Value, ConstReference,Category,ConstPointer>::type const_iterator;
+    Value,const Value&,Category,const Value*>::type const_iterator;
 };
 
 #ifndef BOOST_MSVC
@@ -975,14 +853,14 @@ struct reverse_iterator_policies : public default_iterator_policies
 template <class BidirectionalIterator,
     class Value = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<BidirectionalIterator>::value_type,
     class Reference = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<BidirectionalIterator,Value>::reference,
-    class Pointer = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<BidirectionalIterator,Value>::pointer,
     class Category = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<BidirectionalIterator>::iterator_category,
-    class Distance = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<BidirectionalIterator>::difference_type
+    class Distance = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<BidirectionalIterator>::difference_type,
+    class Pointer = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<BidirectionalIterator,Value>::pointer
          >
 struct reverse_iterator_generator
 {
     typedef iterator_adaptor<BidirectionalIterator,reverse_iterator_policies,
-        Value,Reference,Pointer,Category,Distance> type;
+        Value,Reference,Category,Distance,Pointer> type;
 };
 
 template <class BidirectionalIterator>
@@ -1022,8 +900,12 @@ template <class AdaptableUnaryFunction, class Iterator>
 class const_projection_iterator_generator {
     typedef typename AdaptableUnaryFunction::result_type value_type;
     typedef projection_iterator_policies<AdaptableUnaryFunction> policies;
+    typedef boost::detail::iterator_traits<Iterator> base_traits;
+    typedef typename base_traits::iterator_category iterator_category;
+    typedef typename base_traits::difference_type difference_type;
 public:
-    typedef iterator_adaptor<Iterator,policies,value_type,const value_type&,const value_type*> type;
+    typedef iterator_adaptor<Iterator,policies,value_type,const value_type&,
+        iterator_category,difference_type, const value_type*> type;
 };
 
 template <class AdaptableUnaryFunction, class Iterator, class ConstIterator>
@@ -1086,19 +968,14 @@ public:
         { return x == y; }
 
  private:
-    void satisfy_predicate(Iterator& iter);
+    void satisfy_predicate(Iterator& iter)
+    {
+        while (m_end != iter && !m_predicate(*iter))
+            ++iter;
+    }
     Predicate m_predicate;
     Iterator m_end;
 };
-template <class Predicate, class Iterator>
-void filter_iterator_policies<Predicate,Iterator>
-::satisfy_predicate(Iterator& iter)
-{
-    while (m_end != iter && !m_predicate(*iter))
-        ++iter;
-}
-
-
 
 namespace detail {
   // A type generator returning Base if T is derived from Base, and T otherwise.
@@ -1129,7 +1006,6 @@ namespace detail {
 # else
       // is_convertible doesn't work with MWERKS
       typedef typename iterator_traits<Iterator>::iterator_category input_category;
-  public:
       typedef typename if_true<(
           boost::is_same<input_category,std::random_access_iterator_tag>::value
           || boost::is_same<input_category,std::bidirectional_iterator_tag>::value
@@ -1144,9 +1020,9 @@ namespace detail {
 template <class Predicate, class Iterator, 
     class Value = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<Iterator>::value_type,
     class Reference = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<Iterator,Value>::reference,
-    class Pointer = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<Iterator,Value>::pointer,
     class Category = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::non_bidirectional_category<Iterator>::type,
-    class Distance = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type
+    class Distance = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type,
+    class Pointer = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<Iterator,Value>::pointer
          >
 class filter_iterator_generator {
     BOOST_STATIC_CONSTANT(bool, is_bidirectional
@@ -1157,7 +1033,7 @@ class filter_iterator_generator {
     typedef filter_iterator_policies<Predicate,Iterator> policies_type;
  public:
     typedef iterator_adaptor<Iterator,policies_type,
-        Value,Reference,Pointer,Category,Distance> type;
+        Value,Reference,Category,Distance,Pointer> type;
 };
 
 // This keeps MSVC happy; it doesn't like to deduce default template arguments

include/boost/pending/detail/int_iterator.hpp

@@ -1,75 +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 std::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 += 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; }
-  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
-
-#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
-namespace boost {
-  using ::int_iterator;
-}
-#endif
-
-
-#endif /* BOOST_INT_ITERATOR_H */

include/boost/pending/integer_range.hpp

@@ -1,59 +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.
-//
-// Revision History:
-// 04 Jan 2001  Factored counting_iterator stuff into
-//              boost/counting_iterator.hpp (David Abrahams)
-
-#ifndef BOOST_INTEGER_RANGE_HPP_
-#define BOOST_INTEGER_RANGE_HPP_
-
-#include <boost/config.hpp>
-#include <boost/counting_iterator.hpp>
-
-namespace boost {
-
-//=============================================================================
-// Counting Iterator and Integer Range Class
-
-template <class IntegerType>
-struct integer_range {
-    typedef typename counting_iterator_generator<IntegerType>::type iterator;
-
-    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;
-};
-
-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 +0,0 @@
-#include <boost/iterator_adaptors.hpp>

include/boost/pending/iterator_tests.hpp

@@ -1,214 +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.
-//
-// 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
-
-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; }
-  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(const Iterator i, const 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(const Iterator i, const 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 <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);
-  ++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]);
-  const 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]);
-    Iterator q = k - c; 
-    assert(*i == *q);
-    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