This commit was manufactured by cvs2svn to create branch 'named-args'.

[SVN r9294]

include/boost/counting_iterator.hpp

@@ -1,226 +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
-#  if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
-    BOOST_STATIC_CONSTANT(bool,
-                          value = (
-                              std::numeric_limits<T>::is_specialized
-                              | boost::is_same<T,long long>::value
-                              | boost::is_same<T,unsigned long long>::value));
-#  else
-     BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
-#  endif
-# 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
-{
-    template <class IteratorAdaptor>
-    typename IteratorAdaptor::reference dereference(const IteratorAdaptor& i) const
-        { return i.base(); }
-    
-    template <class Iterator1, class Iterator2>
-    typename Iterator1::difference_type distance(
-        const Iterator1& x, const Iterator2& y) const
-    {
-        typedef typename Iterator1::difference_type difference_type;
-        return boost::detail::any_distance<difference_type>(
-            x.base(), y.base());
-    }
-};
-
-// 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/iterator_adaptors.hpp

@@ -12,16 +12,6 @@
 //
 // Revision History:
 
-// 04 Oct 2001   Jeremy Siek
-//      Changed projection_iterator to not rely on the default reference,
-//      working around a limitation of detail::iterator_traits.
-// 04 Oct 2001   David Abrahams
-//      Applied indirect_iterator patch from George A. Heintzelman <georgeh@aya.yale.edu>
-//      Changed name of "bind" to "select" to avoid problems with MSVC.
-// 26 Sep 2001   David Abrahams
-//      Added borland bug fix
-// 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.
@@ -114,7 +104,6 @@
 # include <boost/type_traits.hpp>
 # include <boost/detail/iterator.hpp>
 # include <boost/detail/select_type.hpp>
-# include <boost/pending/ct_if.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
@@ -146,7 +135,7 @@ struct TrivialIteratorPoliciesConcept
     const_constraints();
   }
   void const_constraints() const {
-    Reference r = p.dereference(x);
+    Reference r = p.dereference(type<Reference>(), x);
     b = p.equal(x, x);
     ignore_unused_variable_warning(r);
   }
@@ -208,7 +197,8 @@ struct RandomAccessIteratorPoliciesConcept
     ignore_unused_variable_warning(t);
   }
   void const_constraints() const {
-    n = p.distance(x, x);
+    n = p.distance(type<DifferenceType>(), x, x);
+    b = p.less(x, x);
   }
   Policies p;
   Adapted x;
@@ -230,30 +220,34 @@ struct default_iterator_policies
     void initialize(Base&)
         { }
 
-    template <class IteratorAdaptor>
-    typename IteratorAdaptor::reference dereference(const IteratorAdaptor& x) const
-        { return *x.base(); }
+    template <class Reference, class Base>
+    Reference dereference(type<Reference>, const Base& x) const
+        { return *x; }
 
-    template <class IteratorAdaptor>
-    void increment(IteratorAdaptor& x)
-        { ++x.base(); }
+    template <class Base>
+    void increment(Base& x)
+        { ++x; }
 
-    template <class IteratorAdaptor>
-    void decrement(IteratorAdaptor& x)
-        { --x.base(); }
+    template <class Base>
+    void decrement(Base& x)
+        { --x; }
 
-    template <class IteratorAdaptor, class DifferenceType>
-    void advance(IteratorAdaptor& x, DifferenceType n)
-        { x.base() += n; }
+    template <class Base, class DifferenceType>
+    void advance(Base& x, DifferenceType n)
+        { x += n; }
 
-    template <class IteratorAdaptor1, class IteratorAdaptor2>
-    typename IteratorAdaptor1::difference_type
-    distance(const IteratorAdaptor1& x, const IteratorAdaptor2& y) const
-        { return y.base() - x.base(); }
+    template <class Difference, class Iterator1, class Iterator2>
+    Difference distance(type<Difference>, const Iterator1& x,
+                        const Iterator2& y) const
+        { return y - x; }
 
-    template <class IteratorAdaptor1, class IteratorAdaptor2>
-    bool equal(const IteratorAdaptor1& x, const IteratorAdaptor2& y) const
-        { return x.base() == y.base(); }
+    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 x < y; }
 };
 
 // putting the comparisons in a base class avoids the g++ 
@@ -269,7 +263,7 @@ inline bool operator==(const iterator_comparisons<D1,Base1>& xb,
 {
         const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
-    return x.policies().equal(x, y);
+    return x.policies().equal(x.iter(), y.iter());
 }
 
 template <class D1, class D2, class Base1, class Base2>
@@ -278,7 +272,7 @@ inline bool operator!=(const iterator_comparisons<D1,Base1>& xb,
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
-    return !x.policies().equal(x, y);
+    return !x.policies().equal(x.iter(), y.iter());
 }
 
 template <class D1, class D2, class Base1, class Base2>
@@ -287,7 +281,7 @@ inline bool operator<(const iterator_comparisons<D1,Base1>& xb,
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
-    return x.policies().distance(x, y) > 0;
+    return x.policies().less(x.iter(), y.iter());
 }
 
 template <class D1, class D2, class Base1, class Base2>
@@ -296,7 +290,7 @@ inline bool operator>(const iterator_comparisons<D1,Base1>& xb,
 { 
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
-    return x.policies().distance(y, x) > 0;
+    return x.policies().less(y.iter(), x.iter());
 }
 
 template <class D1, class D2, class Base1, class Base2>
@@ -305,7 +299,7 @@ inline bool operator>=(const iterator_comparisons<D1,Base1>& xb,
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
-    return !(x.policies().distance(x, y) > 0);
+    return !x.policies().less(x.iter(), y.iter());
 }
 
 template <class D1, class D2, class Base1, class Base2>
@@ -314,7 +308,7 @@ inline bool operator<=(const iterator_comparisons<D1,Base1>& xb,
 {
     const D1& x = static_cast<const D1&>(xb);
     const D2& y = static_cast<const D2&>(yb);
-    return !(x.policies().distance(y, x) > 0);
+    return !x.policies().less(y.iter(), x.iter());
 }
 #endif
 
@@ -409,7 +403,7 @@ namespace detail {
    {
        BOOST_STATIC_CONSTANT(bool, is_ptr = boost::is_pointer<Iterator>::value);
 
-       typedef typename iterator_defaults_select<is_ptr>::template traits<Iterator,Value> traits;
+       typedef iterator_defaults_select<is_ptr>::template traits<Iterator,Value> traits;
        typedef typename traits::pointer pointer;
        typedef typename traits::reference reference;
    };
@@ -435,283 +429,8 @@ namespace detail {
        
    };
 # endif
-
-  //===========================================================================
-  // Specify the defaults for iterator_adaptor's template parameters
-
-  struct default_argument { };
-  // This class template is a workaround for MSVC.
-  struct dummy_default_gen {
-    template <class Base, class Traits>
-    struct select { typedef default_argument type; };
-  };
-  // This class template is a workaround for MSVC.
-  template <class Gen> struct default_generator {
-    typedef dummy_default_gen type;
-  };
-
-  struct default_value_type {
-    template <class Base, class Traits>
-    struct select {
-      typedef typename boost::detail::iterator_traits<Base>::value_type type;
-    };
-  };
-  template <> struct default_generator<default_value_type>
-  { typedef default_value_type type; }; // VC++ workaround
-
-  struct default_difference_type {
-    template <class Base, class Traits>
-    struct select {
-      typedef typename boost::detail::iterator_traits<Base>::difference_type type;
-    };
-  };
-  template <> struct default_generator<default_difference_type>
-  { typedef default_difference_type type; }; // VC++ workaround
-
-  struct default_iterator_category {
-    template <class Base, class Traits>
-    struct select {
-      typedef typename boost::detail::iterator_traits<Base>::iterator_category type;
-    };
-  };
-  template <> struct default_generator<default_iterator_category>
-  { typedef default_iterator_category type; }; // VC++ workaround
-
-  struct default_pointer {
-    template <class Base, class Traits>
-    struct select {
-      typedef typename Traits::value_type Value;
-      typedef typename boost::detail::iterator_defaults<Base,Value>::pointer 
-	type;
-    };
-  };
-  template <> struct default_generator<default_pointer>
-  { typedef default_pointer type; }; // VC++ workaround
-
-  struct default_reference {
-    template <class Base, class Traits>
-    struct select {
-      typedef typename Traits::value_type Value;
-      typedef typename boost::detail::iterator_defaults<Base,Value>::reference 
-	type;
-    };
-  };
-  template <> struct default_generator<default_reference>
-  { typedef default_reference type; }; // VC++ workaround
-
 } // namespace detail
 
-
-  //===========================================================================
-  // Support for named template parameters
-
-struct named_template_param_base { };
-
-namespace detail {
-  struct value_type_tag { };
-  struct reference_tag { };
-  struct pointer_tag { };
-  struct difference_type_tag { };
-  struct iterator_category_tag { };
-
-  // avoid using std::pair because A or B might be a reference type, and g++
-  // complains about forming references to references inside std::pair
-  template <class A, class B>
-  struct cons_type {
-    typedef A first_type;
-    typedef B second_type;
-  };
-
-} // namespace detail
-
-template <class Value> struct value_type_is : public named_template_param_base
-{
-  typedef detail::cons_type<detail::value_type_tag, Value> type;
-};
-template <class Reference> struct reference_is : public named_template_param_base
-{
-  typedef detail::cons_type<detail::reference_tag, Reference> type;
-};
-template <class Pointer> struct pointer_is : public named_template_param_base
-{
-  typedef detail::cons_type<detail::pointer_tag, Pointer> type;
-};
-template <class Difference> struct difference_type_is
-  : public named_template_param_base
-{
-  typedef detail::cons_type<detail::difference_type_tag, Difference> type;
-};
-template <class IteratorCategory> struct iterator_category_is 
-  : public named_template_param_base
-{
-  typedef detail::cons_type<detail::iterator_category_tag, IteratorCategory> type;
-};
-
-namespace detail {
-
-  struct end_of_list { };
-
-  // Given an associative list, find the value with the matching key.
-  // An associative list is a list of key-value pairs. The list is
-  // built out of cons_type's and is terminated by end_of_list.
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  template <class AssocList, class Key>
-  struct find_param;
-
-  struct find_param_continue {
-    template <class AssocList, class Key2> struct bind {
-      typedef typename AssocList::first_type Head;
-      typedef typename Head::first_type Key1;
-      typedef typename Head::second_type Value;
-      typedef typename ct_if<is_same<Key1, Key2>::value,
-        Value, 
-        typename find_param<typename AssocList::second_type, Key2>::type
-      >::type type;
-    };
-  };
-  struct find_param_end {
-    template <class AssocList, class Key>
-    struct bind { typedef detail::default_argument type; };
-  };
-  template <class AssocList> struct find_param_helper1
-  { typedef find_param_continue type; };
-  template <> struct find_param_helper1<end_of_list>
-  { typedef find_param_end type; };
-
-  template <class AssocList, class Key>
-  struct find_param {
-    typedef typename find_param_helper1<AssocList>::type select1;
-    typedef typename select1::template bind<AssocList, Key>::type type;
-  };
-#else
-  template <class AssocList, class Key> struct find_param;
-
-  template <class Key>
-  struct find_param<end_of_list, Key> { typedef default_argument type; };
-
-  // Found a matching Key, return the associated Value
-  template <class Key, class Value, class Rest>
-  struct find_param<detail::cons_type< detail::cons_type<Key, Value>, Rest>, Key> {
-    typedef Value type;
-  };
-
-  // Non-matching keys, continue the search
-  template <class Key1, class Value, class Rest, class Key2>
-  struct find_param<detail::cons_type< detail::cons_type<Key1, Value>, Rest>, Key2> {
-    typedef typename find_param<Rest, Key2>::type type;
-  };
-#endif
-
-  struct make_named_arg {
-    template <class Key, class Value>
-    struct bind { typedef typename Value::type type; };
-  };
-  struct make_key_value {
-    template <class Key, class Value>
-    struct bind { typedef detail::cons_type<Key, Value> type; };
-  };
-
-  template <class Key, class Value>
-  class make_arg {
-    enum { is_named = is_convertible<Value, named_template_param_base>::value };
-    typedef typename ct_if<is_named, make_named_arg, make_key_value>::type Make;
-    typedef typename Make::template bind<Key, Value>::type type;
-  };
-
-  // Mechanism for resolving the default argument for a template parameter.
-
-  template <class T> struct is_default { typedef type_traits::no_type type; };
-  template <> struct is_default<default_argument>
-  { typedef type_traits::yes_type type; };
-
-  struct choose_default {
-    template <class Arg, class DefaultGen, class Base, class Traits>
-    struct bind {
-#if 1
-      typedef typename default_generator<DefaultGen>::type Gen;
-      typedef typename Gen::template select<Base,Traits>::type type;
-#endif
-    };
-  };
-  struct choose_arg {
-    template <class Arg, class DefaultGen, class Base, class Traits>
-    struct bind {
-      typedef Arg type;
-    };
-  };
-
-  template <class UseDefault>
-  struct choose_arg_or_default { typedef choose_arg type; };
-  template <> struct choose_arg_or_default<type_traits::yes_type> {
-    typedef choose_default type;
-  };
-
-  template <class Arg, class DefaultGen, class Base, class Traits>
-  class resolve_default {
-    typedef typename choose_arg_or_default<typename is_default<Arg>::type>::type
-      Selector;
-  public:
-    typedef typename Selector
-      ::template bind<Arg, DefaultGen, Base, Traits>::type type;
-  };
-
-  template <class Base, class Value, class Reference, class Pointer,
-            class Category, class Distance>
-  class iterator_adaptor_traits_gen
-  {
-    // Form an associative list out of the template parameters
-    // If the argument is a normal parameter (not named) then make_arg 
-    // creates a key-value pair. If the argument is a named parameter,
-    // then make_arg extracts the key-value pair defined inside the
-    // named parameter.
-    typedef detail::cons_type< typename make_arg<value_type_tag, Value>::type,
-      detail::cons_type<typename make_arg<reference_tag, Reference>::type,
-      detail::cons_type<typename make_arg<pointer_tag, Pointer>::type,
-      detail::cons_type<typename make_arg<iterator_category_tag, Category>::type,
-      detail::cons_type<typename make_arg<difference_type_tag, Distance>::type,
-                end_of_list> > > > > ArgList;
-
-    // Search the list for particular parameters
-    typedef typename find_param<ArgList, value_type_tag>::type Val;
-    typedef typename find_param<ArgList, difference_type_tag>::type Diff;
-    typedef typename find_param<ArgList, iterator_category_tag>::type Cat;
-    typedef typename find_param<ArgList, pointer_tag>::type Ptr;
-    typedef typename find_param<ArgList, reference_tag>::type Ref;
-
-    typedef boost::iterator<Category, Value, Distance, Pointer, Reference>
-      Traits0;
-
-    // Compute the defaults if necessary
-    typedef typename resolve_default<Val, default_value_type, Base, Traits0>::type
-      value_type;
-    // if getting default value type from iterator_traits, then it won't be const
-    typedef typename resolve_default<Diff, default_difference_type, Base, 
-      Traits0>::type difference_type;
-    typedef typename resolve_default<Cat, default_iterator_category, Base, 
-      Traits0>::type iterator_category;
-
-    typedef boost::iterator<iterator_category, value_type, difference_type,
-      Pointer, Reference> Traits1;
-
-    // Compute the defaults for pointer and reference. This is done as a
-    // separate step because the defaults for pointer and reference depend
-    // on value_type.
-    typedef typename resolve_default<Ptr, default_pointer, Base, Traits1>::type
-      pointer;
-    typedef typename resolve_default<Ref, default_reference, Base, Traits1>::type
-      reference;
-    
-  public:
-    typedef boost::iterator<iterator_category,
-      typename remove_const<value_type>::type, 
-      difference_type, pointer, reference> type;
-  };
-
-} // namespace detail
-
-
-
 // This macro definition is only temporary in this file
 # if !defined(BOOST_MSVC)
 #  define BOOST_ARG_DEPENDENT_TYPENAME typename
@@ -750,32 +469,29 @@ template <class T> struct undefined;
 //   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 = detail::default_argument,
-    class Pointer = detail::default_argument,
-    class Category = detail::default_argument,
-    class Distance = detail::default_argument
+    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 Pointer = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_defaults<Base,Value>::pointer,
+    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
          >
 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
+#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;
  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;
 
@@ -787,57 +503,53 @@ 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() { }
 
     explicit
     iterator_adaptor(const Base& it, const Policies& p = Policies())
         : m_iter_p(it, p) {
-      policies().initialize(base());
+      policies().initialize(iter());
     }
 
     template <class Iter2, class Value2, class Pointer2, class Reference2>
     iterator_adaptor (
         const iterator_adaptor<Iter2,Policies,Value2,Reference2,Pointer2,Category,Distance>& src)
-            : m_iter_p(src.base(), src.policies())
+            : m_iter_p(src.iter(), src.policies())
     {
-        policies().initialize(base());
+        policies().initialize(iter());
     }
 
-#if defined(BOOST_MSVC) || defined(__BORLANDC__)
+#ifdef BOOST_MSVC
     // This is required to prevent a bug in how VC++ generates
-    // the assignment operator for compressed_pairv
+    // the assignment operator for compressed_pair.
     iterator_adaptor& operator= (const iterator_adaptor& x) {
         m_iter_p = x.m_iter_p;
         return *this;
     }
 #endif
     reference operator*() const {
-         return policies().dereference(*this);
+        return policies().dereference(type<reference>(), iter());
     }
 
-#ifdef BOOST_MSVC
+#ifdef _MSC_VER
 # pragma warning(push)
 # 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 BOOST_MSVC
+#ifdef _MSC_VER
 # pragma warning(pop)
 #endif
 
@@ -848,9 +560,9 @@ struct iterator_adaptor :
 #ifdef __MWERKS__
         // Odd bug, MWERKS couldn't  deduce the type for the member template
         // Workaround by explicitly specifying the type.
-        policies().increment<self>(*this);
+        policies().increment<Base>(iter());
 #else
-        policies().increment(*this);
+        policies().increment(iter());
 #endif
         return *this;
     }
@@ -858,39 +570,37 @@ struct iterator_adaptor :
     self operator++(int) { self tmp(*this); ++*this; return tmp; }
     
     self& operator--() {
-#ifdef __MWERKS__
-        policies().decrement<self>(*this);
-#else
-        policies().decrement(*this);
-#endif
+        policies().decrement(iter());
         return *this;
     }
     
     self operator--(int) { self tmp(*this); --*this; return tmp; }
 
     self& operator+=(difference_type n) {
-        policies().advance(*this, n);
+        policies().advance(iter(), n);
         return *this;
     }
   
     self& operator-=(difference_type n) {
-        policies().advance(*this, -n);
+        policies().advance(iter(), -n);
         return *this;
     }
 
-    base_type const& base() const { return m_iter_p.first(); }
+    base_type base() const { return m_iter_p.first(); }
 
     // 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;
 
 public: // implementation details (too many compilers have trouble when these are private).
-    base_type& base() { return m_iter_p.first(); }
     Policies& policies() { return m_iter_p.second(); }
     const Policies& policies() const { return m_iter_p.second(); }
+    
+    Base& iter() { return m_iter_p.first(); }
+    const Base& iter() const { return m_iter_p.first(); }
 };
 
 template <class Base, class Policies, class Value, class Reference, class Pointer,
@@ -916,14 +626,11 @@ operator+(
 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-(
+Distance operator-(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
 {
-  typedef typename iterator_adaptor<Iterator1,Policies,Value1,Reference1,
-    Pointer1,Category,Distance>::difference_type difference_type;
-  return x.policies().distance(y, x);
+    return x.policies().distance(type<Distance>(), y.iter(), x.iter());
 }
 
 #ifndef BOOST_RELOPS_AMBIGUITY_BUG
@@ -935,7 +642,7 @@ operator==(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
 {
-    return x.policies().equal(x, y);
+    return x.policies().equal(x.iter(), y.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
@@ -946,7 +653,7 @@ operator<(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
 {
-    return x.policies().distance(x, y) > 0;
+    return x.policies().less(x.iter(), y.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
@@ -957,7 +664,7 @@ operator>(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
 { 
-    return x.policies().distance(y, x) > 0;
+    return x.policies().less(y.iter(), x.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
@@ -968,7 +675,7 @@ operator>=(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
 {
-    return !(x.policies().distance(x, y) > 0);
+    return !x.policies().less(x.iter(), y.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
@@ -979,7 +686,7 @@ operator<=(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x,
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
 {
-    return !(x.policies().distance(y, x) > 0);
+    return !x.policies().less(y.iter(), x.iter());
 }
 
 template <class Iterator1, class Iterator2, class Policies, class Value1, class Value2,
@@ -990,7 +697,7 @@ operator!=(
     const iterator_adaptor<Iterator1,Policies,Value1,Reference1,Pointer1,Category,Distance>& x, 
     const iterator_adaptor<Iterator2,Policies,Value2,Reference2,Pointer2,Category,Distance>& y)
 {
-    return !x.policies().equal(x, y);
+    return !x.policies().equal(x.iter(), y.iter());
 }
 #endif
 
@@ -1006,10 +713,9 @@ struct transform_iterator_policies : public default_iterator_policies
     transform_iterator_policies() { }
     transform_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
     
-    template <class IteratorAdaptor>
-    typename IteratorAdaptor::reference
-    dereference(const IteratorAdaptor& iter) const
-        { return m_f(*iter.base()); }
+    template <class Reference, class Iterator>
+    Reference dereference(type<Reference>, const Iterator& iter) const
+        { return m_f(*iter); }
 
     AdaptableUnaryFunction m_f;
 };
@@ -1052,19 +758,17 @@ make_transform_iterator(
 
 struct indirect_iterator_policies : public default_iterator_policies
 {
-    template <class IteratorAdaptor>
-    typename IteratorAdaptor::reference dereference(const IteratorAdaptor& x) const
-        { return **x.base(); }
+    template <class Reference, class Iterator>
+    Reference dereference(type<Reference>, const Iterator& x) const
+        { return **x; }
 };
 
 namespace detail {
 # if !defined(BOOST_MSVC) // stragely instantiated even when unused! Maybe try a recursive template someday ;-)
   template <class T>
-  struct traits_of_value_type {
+  struct value_type_of_value_type {
       typedef typename boost::detail::iterator_traits<T>::value_type outer_value;
-      typedef typename boost::detail::iterator_traits<outer_value>::value_type value_type;
-      typedef typename boost::detail::iterator_traits<outer_value>::reference reference;
-      typedef typename boost::detail::iterator_traits<outer_value>::pointer pointer;
+      typedef typename boost::detail::iterator_traits<outer_value>::value_type type;
   };
 # endif
 }
@@ -1072,25 +776,11 @@ namespace detail {
 template <class OuterIterator,      // Mutable or Immutable, does not matter
           class Value
 #if !defined(BOOST_MSVC)
-                = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
-                        OuterIterator>::value_type
-#endif
-          , class Reference 
-#if !defined(BOOST_MSVC)
-                = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
-                        OuterIterator>::reference
-#else
-                = Value &
-#endif
-          , class Category = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<
-                        OuterIterator>::iterator_category
-          , class Pointer 
-#if !defined(BOOST_MSVC)
-                = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
-                        OuterIterator>::pointer
-#else
-                = Value*
+                = BOOST_ARG_DEPENDENT_TYPENAME detail::value_type_of_value_type<OuterIterator>::type
 #endif
+          , class Reference = Value&
+          , class Category = BOOST_ARG_DEPENDENT_TYPENAME boost::detail::iterator_traits<OuterIterator>::iterator_category
+          , class Pointer = Value*
          >
 struct indirect_iterator_generator
 {
@@ -1101,26 +791,12 @@ struct indirect_iterator_generator
 template <class OuterIterator,      // Mutable or Immutable, does not matter
           class Value
 #if !defined(BOOST_MSVC)
-                = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
-                        OuterIterator>::value_type
-#endif
-          , class Reference 
-#if !defined(BOOST_MSVC)
-                = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
-                        OuterIterator>::reference
-#else
-                = Value &
+                = 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 
-#if !defined(BOOST_MSVC)
-                = BOOST_ARG_DEPENDENT_TYPENAME detail::traits_of_value_type<
-                        OuterIterator>::pointer
-#else
-                = Value*
-#endif
+          , 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
@@ -1147,30 +823,34 @@ make_indirect_iterator(OuterIterator base)
 
 struct reverse_iterator_policies : public default_iterator_policies
 {
-    template <class IteratorAdaptor>
-    typename IteratorAdaptor::reference dereference(const IteratorAdaptor& x) const
-        { return *boost::prior(x.base()); }
+    template <class Reference, class BidirectionalIterator>
+    Reference dereference(type<Reference>, const BidirectionalIterator& x) const
+        { return *boost::prior(x); }
     
     template <class BidirectionalIterator>
     void increment(BidirectionalIterator& x) const
-        { --x.base(); }
+        { --x; }
     
     template <class BidirectionalIterator>
     void decrement(BidirectionalIterator& x) const
-        { ++x.base(); }
+        { ++x; }
     
     template <class BidirectionalIterator, class DifferenceType>
     void advance(BidirectionalIterator& x, DifferenceType n) const
-        { x.base() -= n; }
+        { x -= n; }
     
-    template <class Iterator1, class Iterator2>
-    typename Iterator1::difference_type distance(
-        const Iterator1& x, const Iterator2& y) const
-        { return x.base() - y.base(); }
+    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.base() == y.base(); }
+        { return x == y; }
+    
+    template <class Iterator1, class Iterator2>
+    bool less(const Iterator1& x, const Iterator2& y) const
+        { return y < x; }
 };
   
 template <class BidirectionalIterator,
@@ -1203,9 +883,9 @@ struct projection_iterator_policies : public default_iterator_policies
     projection_iterator_policies() { }
     projection_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
 
-    template <class IteratorAdaptor>
-    typename IteratorAdaptor::reference dereference(IteratorAdaptor const& iter) const {
-        return m_f(*iter.base());
+    template <class Reference, class Iterator>
+    Reference dereference (type<Reference>, Iterator const& iter) const {
+        return m_f(*iter);
     }
 
     AdaptableUnaryFunction m_f;    
@@ -1216,7 +896,7 @@ class projection_iterator_generator {
     typedef typename AdaptableUnaryFunction::result_type value_type;
     typedef projection_iterator_policies<AdaptableUnaryFunction> policies;
 public:
-    typedef iterator_adaptor<Iterator,policies,value_type,value_type&,value_type*> type;
+    typedef iterator_adaptor<Iterator,policies,value_type> type;
 };
 
 template <class AdaptableUnaryFunction, class Iterator>
@@ -1272,36 +952,30 @@ public:
 
     // The Iter template argument is neccessary for compatibility with a MWCW
     // bug workaround
-    template <class IteratorAdaptor>
-    void increment(IteratorAdaptor& x) {
-        ++x.base();
-        satisfy_predicate(x.base());
+    template <class Iter>
+    void increment(Iter& x) {
+        ++x;
+        satisfy_predicate(x);
     }
 
-    template <class IteratorAdaptor>
-    typename IteratorAdaptor::reference dereference(const IteratorAdaptor& x) const
-        { return *x.base(); }
+    template <class Reference, class Iter>
+    Reference dereference(type<Reference>, const Iter& x) const
+        { return *x; }
 
-    template <class IteratorAdaptor1, class IteratorAdaptor2>
-    bool equal(const IteratorAdaptor1& x, const IteratorAdaptor2& y) const
-        { return x.base() == y.base(); }
+    template <class Iterator1, class Iterator2>
+    bool equal(const Iterator1& x, const Iterator2& y) const
+        { 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.
   template <class Base, class T>
@@ -1331,7 +1005,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