Merge pull request #9 from boostorg/develop

Merge develop into master

Tested with gcc-4.2.1 on Darwin.

development/boost/iterator_categories.hpp

@@ -1,159 +0,0 @@
-#ifndef BOOST_ITERATOR_CATEGORIES_HPP
-#define BOOST_ITERATOR_CATEGORIES_HPP
-
-#include <boost/config.hpp>
-#include <boost/type_traits/conversion_traits.hpp>
-#include <boost/type_traits/cv_traits.hpp>
-#include <boost/pending/ct_if.hpp>
-#include <boost/detail/iterator.hpp>
-
-namespace boost {
-
-  // Return Type Categories
-  struct readable_iterator_tag { };
-  struct writable_iterator_tag { };
-  struct swappable_iterator_tag { };
-  struct mutable_lvalue_iterator_tag : 
-    virtual public writable_iterator_tag,
-    virtual public readable_iterator_tag { };
-  struct constant_lvalue_iterator_tag : 
-    virtual public readable_iterator_tag { };
-
-  // Traversal Categories
-  struct forward_traversal_tag { };
-  struct bidirectional_traversal_tag : public forward_traversal_tag { };
-  struct random_access_traversal_tag : public bidirectional_traversal_tag { };
-
-  struct error_iterator_tag { };
-
-  // Inherit from iterator_base if your iterator defines its own
-  // return_category and traversal_category. Otherwise, the "old style"
-  // iterator category will be mapped to the return_category and
-  // traversal_category.
-  struct new_iterator_base { };
-
-  namespace detail {
-
-    struct return_category_from_nested_type {
-      template <typename Iterator> struct bind {
-        typedef typename Iterator::return_category type;
-      };
-    };
-
-    struct traversal_category_from_nested_type {
-      template <typename Iterator> struct bind {
-        typedef typename Iterator::traversal_category type;
-      };
-    };
-
-    template <typename ValueType>
-    struct choose_lvalue_return {
-      typedef typename ct_if<is_const<ValueType>::value,
-                             boost::constant_lvalue_iterator_tag,
-                             boost::mutable_lvalue_iterator_tag>::type type;
-    };
-    
-    
-    template <typename Category, typename ValueType>
-    struct iter_category_to_return {
-      typedef typename ct_if<
-        is_convertible<Category*, std::forward_iterator_tag*>::value,
-        typename choose_lvalue_return<ValueType>::type,
-        typename ct_if<
-          is_convertible<Category*, std::input_iterator_tag*>::value,
-          boost::readable_iterator_tag,
-          typename ct_if<
-            is_convertible<Category*, std::output_iterator_tag*>::value,
-            boost::writable_iterator_tag,
-            boost::error_iterator_tag
-          >::type
-       >::type
-      >::type type;
-    };
-
-    template <typename Category>
-    struct iter_category_to_traversal {
-      typedef typename ct_if<
-        is_convertible<Category*, std::random_access_iterator_tag*>::value,
-        random_access_traversal_tag,
-        typename ct_if<
-          is_convertible<Category*, std::bidirectional_iterator_tag*>::value,
-          bidirectional_traversal_tag,
-          forward_traversal_tag
-          >::type
-        >::type type;
-    };
-
-    struct return_category_from_old_traits {
-      template <typename Iterator> class bind {
-        typedef boost::detail::iterator_traits<Iterator> OldTraits;
-        typedef typename OldTraits::iterator_category Cat;
-        typedef typename OldTraits::value_type value_type;
-      public:
-        typedef iter_category_to_return<Cat, value_type>::type type;
-      };      
-    };
-
-    struct traversal_category_from_old_traits {
-      template <typename Iterator> class bind {
-        typedef boost::detail::iterator_traits<Iterator> OldTraits;
-        typedef typename OldTraits::iterator_category Cat;
-      public:
-        typedef iter_category_to_traversal<Cat>::type type;
-      };      
-    };
-
-    template <typename Iterator>
-    class choose_return_category {
-      typedef typename ct_if<is_convertible<Iterator*,
-                                            new_iterator_base*>::value,
-                             return_category_from_nested_type,
-                             return_category_from_old_traits>::type Choice;
-    public:
-      typedef typename Choice:: template bind<Iterator>::type type;
-    };
-
-    template <typename Iterator>
-    class choose_traversal_category {
-      typedef typename ct_if<is_convertible<Iterator*,
-                                            new_iterator_base*>::value,
-                             traversal_category_from_nested_type,
-                             traversal_category_from_old_traits>::type Choice;
-    public:
-      typedef typename Choice:: template bind<Iterator>::type type;
-    };
-    
-  } // namespace detail
-  
-  template <class Iterator>
-  struct return_category {
-    typedef typename detail::choose_return_category<Iterator>::type type;
-  };
-
-
-  template <class Iterator>
-  struct traversal_category {
-    typedef typename detail::choose_traversal_category<Iterator>::type type;
-  };
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-  template <typename T>
-  struct return_category<T*>
-  {
-    typedef typename ct_if<is_const<T>::value,
-      constant_lvalue_iterator_tag,
-      mutable_lvalue_iterator_tag>::type type;
-  };
-
-  template <typename T>
-  struct traversal_category<T*>
-  {
-    typedef random_access_traversal_tag type;
-  };
-
-#endif
-
-} // namespace boost
-
-#endif // BOOST_ITERATOR_CATEGORIES_HPP

development/boost/iterator_concepts.hpp

@@ -1,172 +0,0 @@
-#ifndef BOOST_ITERATOR_CONCEPTS_HPP
-#define BOOST_ITERATOR_CONCEPTS_HPP
-
-#include <boost/concept_check.hpp>
-#include <boost/iterator_categories.hpp>
-#include <boost/type_traits/conversion_traits.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost_concepts {
-  // Used a different namespace here (instead of "boost") so that the
-  // concept descriptions do not take for granted the names in
-  // namespace boost.
-
-
-  //===========================================================================
-  // Iterator Access Concepts
-
-  template <typename Iterator>
-  class ReadableIteratorConcept {
-  public:
-    typedef typename std::iterator_traits<Iterator>::value_type value_type;
-    typedef typename std::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::return_category<Iterator>::type return_category;
-
-    void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
-      boost::function_requires< 
-        boost::DefaultConstructibleConcept<Iterator> >();
-      
-      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*,
-                           boost::readable_iterator_tag*>::value));
-                          
-      reference r = *i; // or perhaps read(x)
-      value_type v(r);
-      boost::ignore_unused_variable_warning(v);
-    }
-    Iterator i;
-  };
-  
-  template <typename Iterator, typename ValueType>
-  class WritableIteratorConcept {
-  public:
-    typedef typename boost::return_category<Iterator>::type return_category;
-
-    void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
-      boost::function_requires< 
-        boost::DefaultConstructibleConcept<Iterator> >();
-      
-      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*,
-                           boost::writable_iterator_tag*>::value));
-
-      *i = v; // a good alternative could be something like write(x, v)
-    }
-    ValueType v;
-    Iterator i;
-  };
-  
-  template <typename Iterator>
-  class ConstantLvalueIteratorConcept {
-  public:
-    typedef typename std::iterator_traits<Iterator>::value_type value_type;
-    typedef typename std::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::return_category<Iterator>::type return_category;
-
-    void constraints() {
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-
-      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*, 
-                           boost::constant_lvalue_iterator_tag*>::value));
-
-      BOOST_STATIC_ASSERT((boost::is_same<reference, 
-                           const value_type&>::value));
-
-      reference v = *i;
-      boost::ignore_unused_variable_warning(v);
-    }
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class MutableLvalueIteratorConcept {
-  public:
-    typedef typename std::iterator_traits<Iterator>::value_type value_type;
-    typedef typename std::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::return_category<Iterator>::type return_category;
-
-    void constraints() {
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-      boost::function_requires< 
-        WritableIteratorConcept<Iterator, value_type> >();
-      
-      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*, 
-                           boost::mutable_lvalue_iterator_tag*>::value));
-
-      BOOST_STATIC_ASSERT((boost::is_same<reference, value_type&>::value));
-
-      reference v = *i;
-      boost::ignore_unused_variable_warning(v);
-    }
-    Iterator i;
-  };
-  
-  //===========================================================================
-  // Iterator Traversal Concepts
-
-  template <typename Iterator>
-  class ForwardIteratorConcept {
-  public:
-    typedef typename boost::traversal_category<Iterator>::type traversal_category;
-
-    void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
-      boost::function_requires< 
-        boost::DefaultConstructibleConcept<Iterator> >();
-
-      BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, 
-                           boost::forward_traversal_tag*>::value));
-      ++i;
-      (void)i++;
-    }
-    Iterator i;
-  };
-  
-  template <typename Iterator>
-  class BidirectionalIteratorConcept {
-  public:
-    typedef typename boost::traversal_category<Iterator>::type traversal_category;
-
-    void constraints() {
-      boost::function_requires< ForwardIteratorConcept<Iterator> >();
-      
-      BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, 
-                           boost::bidirectional_traversal_tag*>::value));
-
-      --i;
-      (void)i--;
-    }
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class RandomAccessIteratorConcept {
-  public:
-    typedef typename boost::traversal_category<Iterator>::type traversal_category;
-    typedef typename std::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< BidirectionalIteratorConcept<Iterator> >();
-
-      BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, 
-                           boost::random_access_traversal_tag*>::value));
-      
-      i += n;
-      i = i + n;
-      i = n + i;
-      i -= n;
-      i = i - n;
-      n = i - j;
-    }
-    difference_type n;
-    Iterator i, j;
-  };
-
-} // namespace boost_concepts
-
-
-#endif // BOOST_ITERATOR_CONCEPTS_HPP

development/libs/iterator/concept_tests.cpp

@@ -1,73 +0,0 @@
-#include <boost/iterator_concepts.hpp>
-#include <boost/operators.hpp>
-
-struct new_iterator
-  : public boost::iterator<std::random_access_iterator_tag, int>,
-    public boost::new_iterator_base
-{
-  typedef boost::random_access_traversal_tag traversal_category;
-  typedef boost::mutable_lvalue_iterator_tag return_category;
-
-  int& operator*() const { return *m_x; }
-  new_iterator& operator++() { return *this; }
-  new_iterator operator++(int) { return *this; }
-  new_iterator& operator--() { return *this; }
-  new_iterator operator--(int) { return *this; }
-  new_iterator& operator+=(std::ptrdiff_t) { return *this; }
-  new_iterator operator+(std::ptrdiff_t) { return *this; }
-  new_iterator& operator-=(std::ptrdiff_t) { return *this; }
-  std::ptrdiff_t operator-(const new_iterator&) const { return 0; }
-  new_iterator operator-(std::ptrdiff_t) const { return *this; }
-  bool operator==(const new_iterator&) const { return false; }
-  bool operator!=(const new_iterator&) const { return false; }
-  bool operator<(const new_iterator&) const { return false; }
-  int* m_x;
-};
-new_iterator operator+(std::ptrdiff_t, new_iterator x) { return x; }
-
-struct old_iterator
-  : public boost::iterator<std::random_access_iterator_tag, int>
-{
-  int& operator*() const { return *m_x; }
-  old_iterator& operator++() { return *this; }
-  old_iterator operator++(int) { return *this; }
-  old_iterator& operator--() { return *this; }
-  old_iterator operator--(int) { return *this; }
-  old_iterator& operator+=(std::ptrdiff_t) { return *this; }
-  old_iterator operator+(std::ptrdiff_t) { return *this; }
-  old_iterator& operator-=(std::ptrdiff_t) { return *this; }
-  old_iterator operator-(std::ptrdiff_t) const { return *this; }
-  std::ptrdiff_t operator-(const old_iterator&) const { return 0; }
-  bool operator==(const old_iterator&) const { return false; }
-  bool operator!=(const old_iterator&) const { return false; }
-  bool operator<(const old_iterator&) const { return false; }
-  int* m_x;
-};
-old_iterator operator+(std::ptrdiff_t, old_iterator x) { return x; }
-
-int
-main()
-{
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-  boost::function_requires<
-    boost_concepts::MutableLvalueIteratorConcept<int*> >();
-  boost::function_requires<
-    boost_concepts::RandomAccessIteratorConcept<int*> >();
-
-  boost::function_requires<
-    boost_concepts::ConstantLvalueIteratorConcept<const int*> >();
-  boost::function_requires<
-    boost_concepts::RandomAccessIteratorConcept<const int*> >();
-#endif
-
-  boost::function_requires<
-    boost_concepts::MutableLvalueIteratorConcept<new_iterator> >();
-  boost::function_requires<
-    boost_concepts::RandomAccessIteratorConcept<new_iterator> >();
-
-  boost::function_requires<
-    boost_concepts::MutableLvalueIteratorConcept<old_iterator> >();
-  boost::function_requires<
-    boost_concepts::RandomAccessIteratorConcept<old_iterator> >();
-  return 0;
-}

development/libs/iterator/iterator_categories.htm

@@ -1,160 +0,0 @@
-<html>
-<!--
-  -- Copyright (c) Jeremy Siek 2000,2001
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  I make no representations about the
-  -- suitability of this software for any purpose.  It is provided "as is"
-  -- without express or implied warranty.
-  -->
-  <head>
-    <title>Boost Iterator Traits</title>
-  </head>
-
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-	ALINK="#ff0000"> 
-<IMG SRC="../../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-<BR Clear>
-
-    <h1>Boost Iterator Category Traits</h1>
-Header <tt><a href="../../boost/iterator_categories.hpp">boost/iterator_categories.hpp</a></tt>
-
-<p>
-The <tt>boost::traversal_category</tt> and
-<tt>boost::return_category</tt> traits classes provides access to the
-category tags for iterators that model the Boost <a
-href="./iterator_concepts.htm">Iterator Concepts</a>, which are a
-replacement for the iterator requirements in the C++ standard.  The
-other associated types of the Boost iterator concepts are accessed
-through the <tt>std::iterator_traits</tt> class.
-
-<ul>
-  <li><tt>traversal_category&lt;Iter&gt;::type</tt>&nbsp;&nbsp; Can the iterator go forward, backward, etc.?
-  <li><tt>return_category&lt;Iter&gt;::type</tt>&nbsp;&nbsp; Is the iterator read or write only?
-    Is the dereferenced type an lvalue?
-</ul>
-
-<p>
-An important feature of the <tt>boost::traversal_category</tt> and
-<tt>boost::return_category</tt> classes is that they are <b>backwards
-compatible</b>, i.e., they automatically work for iterators for which
-there are valid definitions of <tt>std::iterator_traits</tt>. The old
-<tt>iterator_category</tt> is mapped to the appropriate traversal and
-return categories.
-
-<p>
-When creating a new iterator type that is meant to work with
-<tt>boost::traversal_category</tt> and
-<tt>boost::return_category</tt>, you can either create a
-specialization of these classes for your iterator type, or you can
-provide all the necessary associated types as nested typedefs.  In
-this case, your iterator class will need to inherit from
-<tt>new_iterator_base</tt> to let the category traits know
-that it will be able to find typedefs for <tt>traversal_category</tt>
-and <tt>return_category</tt> in you iterator class.
-
-
-Each of the new iterator requirements will need a category tag.
-
-<pre>
-namespace boost {
-
-  // Return Type Categories
-  struct readable_iterator_tag { };
-  struct writable_iterator_tag { };
-  struct swappable_iterator_tag { };
-  struct mutable_lvalue_iterator_tag : virtual public writable_iterator_tag,
-    virtual public readable_iterator_tag { };
-  struct constant_lvalue_iterator_tag : public readable_iterator_tag { };
-
-  // Traversal Categories
-  struct forward_traversal_tag { };
-  struct bidirectional_traversal_tag : public forward_traversal_tag { };
-  struct random_access_traversal_tag : public bidirectional_traversal_tag { };
-
-}
-</pre>  
-
-<p>
-The following is pseudo-code for the iterator category traits classes.
-
-<pre>
-namespace boost {
-
-  <i>// Inherit from iterator_base if your iterator defines its own
-  // return_category and traversal_category. Otherwise, the "old style"
-  // iterator category will be mapped to the return_category and
-  // traversal_category.</i>
-  struct new_iterator_base { };
-
-  template &lt;typename Iterator&gt;
-  struct return_category
-  {
-    <b><i>// Pseudo-code</i></b>
-    if (Iterator inherits from new_iterator_base) {
-      typedef typename Iterator::return_category type;
-    } else {
-      typedef std::iterator_traits&lt;Iterator&gt; OldTraits;
-      typedef typename OldTraits::iterator_category Cat;
-      if (Cat inherits from std::forward_iterator_tag)
-	if (is-const(T))
-	  typedef boost::constant_lvalue_iterator_tag type;
-	else
-	  typedef boost::mutable_lvalue_iterator_tag type;
-      else if (Cat inherits from std::input_iterator_tag)
-	typedef boost::readable_iterator_tag type;
-      else if (Cat inherits from std::output_iterator_tag)
-	typedef boost::writable_iterator_tag type;
-    }
-  };
-
-  template &lt;typename T&gt;
-  struct return_category&lt;T*&gt;
-  {
-    <b><i>// Pseudo-code</i></b>
-    if (is-const(T))
-      typedef boost::constant_lvalue_iterator_tag type;
-    else
-      typedef boost::mutable_lvalue_iterator_tag type;
-  };
-
-  template &lt;typename Iterator&gt;
-  struct traversal_category
-  {
-    <b><i>// Pseudo-code</i></b>
-    if (Iterator inherits from new_iterator_base) {
-      typedef typename Iterator::traversal_category type;
-    } else {
-      typedef std::iterator_traits&lt;Iterator&gt; OldTraits;
-      typedef typename OldTraits::iterator_category Cat;
-
-      if (Cat inherits from std::random_access_iterator_tag)
-	typedef boost::random_access_traversal_tag type;
-      else if (Cat inherits from std::bidirectional_iterator_tag)
-	typedef boost::bidirectional_traversal_tag type;
-      else if (Cat inherits from std::forward_iterator_tag)
-	typedef boost::forward_traversal_tag type;
-    }
-  };
-
-  template &lt;typename T&gt;
-  struct traversal_category&lt;T*&gt;
-  {
-    typedef boost::random_access_traversal_tag type;
-  };
-
-}
-</pre>
-
-    <hr>
-    <address><a href="mailto:jsiek@lsc.nd.edu">jeremy siek</a></address>
-<!-- Created: Sun Mar 18 14:06:57 EST 2001 -->
-<!-- hhmts start -->
-Last modified: Mon Mar 19 12:59:30 EST 2001
-<!-- hhmts end -->
-  </body>
-</html>

development/libs/iterator/iterator_concepts.fig

@@ -1,37 +0,0 @@
-#FIG 3.2
-Landscape
-Center
-Inches
-Letter  
-100.00
-Single
--2
-1200 2
-6 150 2325 4275 4350
-2 1 0 1 0 7 100 0 -1 4.000 0 0 -1 1 0 2
-	1 1 1.00 60.00 120.00
-	 1725 4050 1725 3450
-2 1 0 1 0 7 100 0 -1 4.000 0 0 -1 1 0 2
-	1 1 1.00 60.00 120.00
-	 1725 3150 1725 2550
-4 0 0 100 0 19 18 0.0000 4 210 3180 375 2550 ForwardTraversalIterator\001
-4 0 0 100 0 19 18 0.0000 4 210 3765 225 3450 BidirectionalTraversalIterator\001
-4 0 0 100 0 19 18 0.0000 4 210 4125 150 4350 RandomAccessTraversalIterator\001
--6
-2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2
-	1 1 1.00 60.00 120.00
-	 4800 3600 4800 2400
-2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2
-	1 1 1.00 60.00 120.00
-	 6900 3000 5400 2400
-2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2
-	1 1 1.00 60.00 120.00
-	 6900 3000 7500 2400
-2 1 0 1 0 7 50 0 -1 0.000 0 0 -1 1 0 2
-	1 1 1.00 60.00 120.00
-	 6900 3000 9075 2475
-4 0 0 100 0 19 18 0.0000 4 210 2040 6600 2400 WritableIterator\001
-4 0 0 100 0 19 18 0.0000 4 210 2145 3900 2400 ReadableIterator\001
-4 0 0 50 0 19 18 0.0000 4 210 2835 5700 3300 MutableLvalueIterator\001
-4 0 0 50 0 19 18 0.0000 4 270 2355 9075 2400 SwappableIterator\001
-4 0 0 50 0 19 18 0.0000 4 210 2970 3825 3900 ConstantLvalueIterator\001

development/libs/iterator/iterator_concepts.htm

@@ -1,663 +0,0 @@
-<HTML>
-<!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  I make no representations about the
-  -- suitability of this software for any purpose.  It is provided "as is"
-  -- without express or implied warranty.
-  -->
-<!--
-  -- Copyright (c) 1996-1999
-  -- Silicon Graphics Computer Systems, Inc.
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  --
-  -- Copyright (c) 1994
-  -- Hewlett-Packard Company
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Hewlett-Packard Company makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  --
-  -->
-<Head>
-<Title>Iterator Concepts</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-	ALINK="#ff0000"> 
-<IMG SRC="../../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<h1>Iterator Concepts</h1>
-
-<p>The standard iterator categories and requirements are flawed because
-they use a single hierarchy of requirements to address two orthogonal
-issues: <b><i>iterator traversal</i></b> and <b><i>dereference return
-type</i></b>. The current iterator requirement hierarchy is mainly
-geared towards iterator traversal (hence the category names), while
-requirements that address dereference return type sneak in at various
-places. 
-
-<p>
-The iterator requirements should be separated into two hierarchies.
-One set of concepts handles the return type semantics: 
-<ul>
-  <li><a href="#concept:ReadableIterator">Readable Iterator</a></li>
-  <li><a href="#concept:WritableIterator">Writable Iterator</a></li>
-  <li><a href="#concept:SwappableIterator">Swappable Iterator</a></li>
-  <li><a href="#concept:ConstantLvalueIterator">Constant Lvalue Iterator</a></li>
-  <li><a href="#concept:MutableLvalueIterator">Mutable Lvalue Iterator</a></li>
-</ul>
-
-The other set of concepts handles iterator traversal: 
-
-<ul>
-  <li><a href="#concept:ForwardTraversalIterator">Forward Traversal Iterator</a></li>
-  <li><a href="#concept:BidirectionalTraversalIterator">Bidirectional Traversal Iterator</a></li>
-  <li><a href="#concept:RandomAccessTraversalIterator">Random Access Traversal Iterator</a></li>
-</ul>
-
-The current Input Iterator and Output Iterator requirements will
-continue to be used as is. Note that Input Iterator implies Readable
-Iterator and Output Iterator implies Writable Iterator.
-
-<p>
-Note: we considered defining a Single-Pass Iterator, which could be
-combined with Readable or Writable Iterator to replace the Input and
-Output Iterator requirements. We rejected this idea because there are
-some differences between Input and Output Iterators that make it hard
-to merge them: for example Input Iterator requires Equality Comparable
-while Output Iterator does not.
-
-
-<p></p>
-<DIV ALIGN="CENTER"><A NAME="fig:graph-concepts"></A></A>
-<TABLE>
-<CAPTION ALIGN="TOP"><STRONG>Figure 1:</STRONG>
-The iterator concepts and refinement relationships.
-</CAPTION>
-<TR><TD><IMG SRC="./iterator_concepts.gif" ></TD></TR>
-</TABLE>
-</DIV>
-<p></p>
-
-
-<h2>Relationship with the standard iterator concepts</h2>
-
-<p>
-std::Input Iterator implies boost::ReadableIterator.
-
-<p>
-std::Output Iterator implies boost::Writable Iterator.
-
-<p>
-std::Forward Iterator refines boost::Forward Iterator and
-boost::Constant Lvalue Iterator or boost::Mutable Lvalue Iterator.
-
-<p>
-std::Bidirectional Iterator refines boost::Bidirectional Iterator and
-boost::Constant Lvalue Iterator or boost::Mutable Lvalue Iterator.
-
-<p>
-std::Random Access Iterator refines boost::Random Access Iterator and
-boost::Constant Lvalue Iterator or boost::Mutable Lvalue Iterator.
-
-
-<h3>Notation</h3>
-<Table>
-  <tr>
-    <td><tt>X</tt></td>
-    <td>The iterator type.</td>
-  </tr>
-  <tr>
-    <td><tt>T</tt></td>
-    <td>The value type of <tt>X</tt>, i.e., <tt>std::iterator_traits&lt;X&gt;::value_type</tt>.</td>
-  </tr>
-  <tr>
-    <td><tt>x</tt>, <tt>y</tt></td>
-    <td>An object of type <tt>X</tt>.</td>
-  </tr>
-  <tr>
-    <td><tt>t</tt></td>
-    <td>An object of type <tt>T</tt>.</td>
-  </tr>
-</table>
-
-<p>
-
-<hr>
-<!--------------------------------------------------------------------------->
-
-<H3><A NAME="concept:ReadableIterator"></A>
-Readable Iterator
-</H3>
-
-A Readable Iterator is an iterator that dereferences to produce an
-rvalue that is convertible to the <tt>value_type</tt> of the
-iterator. 
-
-<h3>Associated Types</h3>
-
-<Table border>
-
-  <tr>
-    <td>Value type</td>
-    <td><tt>std::iterator_traits&lt;X&gt;::value_type</tt></td>
-    <td>The type of the objects pointed to by the iterator.</td>
-  </tr>
-
-  <tr>
-    <td>Reference type</td>
-    <td><tt>std::iterator_traits&lt;X&gt;::reference</tt></td>
-    <td>
-    The return type of dereferencing the iterator. This
-    type must be convertible to <tt>T</tt>.
-    </td>
-  </tr>
-
-  <tr>
-    <td>Return Category</td>
-    <td><tt>std::return_category&lt;X&gt;::type</tt></td>
-    <td>
-    A type convertible to <tt>std::readable_iterator_tag</tt>
-    </td>
-  </tr>
-
-</Table>
-
-<h3>Refinement of</h3>
-
-<A href="http://www.boost.org/libs/utility/CopyConstructible.html">Copy Constructible</A>
-
-<h3>Valid expressions</h3>
-
-<Table border>
-<tr><TH>Name</TH><TH>Expression</TH><TH>Type requirements</TH><TH>Return type</TH></tr>
-<tr>
- <td>Dereference</td>
- <td><tt>*x</tt></td>
- <td>&nbsp;</td>
- <td><tt>std::iterator_traits&lt;X&gt;::reference</tt></td>
-</tr>
-<tr>
- <td>Member access</td>
- <td><tt>x-&gt;m</tt></td>
- <td><tt>T</tt> is a type with a member named <tt>m</tt>.</td>
- <td>
-If <tt>m</tt> is a data member, the type of <tt>m</tt>.
-If <tt>m</tt> is a member function, the return type of <tt>m</tt>.
- </td>
-</tr>
-</table>
-
-<p>
-
-<hr>
-<!--------------------------------------------------------------------------->
-
-<H3><A NAME="concept:WritableIterator"></A>
-Writable Iterator
-</H3>
-
-A Writable Iterator is an iterator that can be used to store a value
-using the dereference-assignment expression.
-
-<h3>Definitions</h3>
-
-If <tt>x</tt> is an Writable Iterator of type <tt>X</tt>, then the
-expression <tt>*x = a;</tt> stores the value <tt>a</tt> into
-<tt>x</tt>.  Note that <tt>operator=</tt>, like other C++ functions,
-may be overloaded; it may, in fact, even be a template function.  In
-general, then, <tt>a</tt> may be any of several different types.  A
-type <tt>A</tt> belongs to the <i>set of value types</i> of <tt>X</tt>
-if, for an object <tt>a</tt> of type <tt>A</tt>, <tt>*x = a;</tt> is
-well-defined and does not require performing any non-trivial
-conversions on <tt>a</tt>.
-
-<h3>Associated Types</h3>
-
-<Table border>
-
-  <tr>
-    <td>Return Category</td>
-    <td><tt>std::return_category&lt;X&gt;::type</tt></td>
-    <td>
-    A type convertible to <tt>std::writable_iterator_tag</tt>
-    </td>
-  </tr>
-
-</Table>
-
-
-
-<h3>Refinement of</h3>
-
-<A href="http://www.boost.org/libs/utility/CopyConstructible.html">Copy Constructible</A>
-
-<h3>Valid expressions</h3>
-
-<Table border>
-  <tr>
-    <TH>Name</TH><TH>Expression</TH><TH>Return type</TH>
-  </tr>
-  <tr>
-    <td>Dereference assignment</td>
-    <td><tt>*x = a</tt></td>
-    <td>unspecified</td>
-  </tr>
-</table>
-
-<p>
-
-
-<hr>
-<!--------------------------------------------------------------------------->
-
-<H3><A NAME="concept:SwappableIterator"></A>
-Swappable Iterator
-</H3>
-
-A Swappable Iterator is an iterator whose dereferenced values can be
-swapped.
-
-<p>
-Note: the requirements for Swappable Iterator are dependent on the
-issues surrounding <tt>std::swap()</tt> being resolved. Here we assume
-that the issue will be resolved by allowing the overload of
-<tt>std::swap()</tt> for user-defined types.
-
-<p>
-Note: Readable Iterator and Writable Iterator combined implies
-Swappable Iterator because of the fully templated
-<tt>std::swap()</tt>.  However, Swappable Iterator does not imply
-Readable Iterator nor Writable Iterator.
-
-<h3>Associated Types</h3>
-
-<Table border>
-
-  <tr>
-    <td>Return Category</td>
-    <td><tt>std::return_category&lt;X&gt;::type</tt></td>
-    <td>
-    A type convertible to <tt>std::swappable_iterator_tag</tt>
-    </td>
-  </tr>
-
-</Table>
-
-
-<h3>Valid expressions</h3>
-
-Of the two valid expressions listed below, only one <b>OR</b> the
-other is required. If <tt>std::iter_swap()</tt> is overloaded for
-<tt>X</tt> then <tt>std::swap()</tt> is not required. If
-<tt>std::iter_swap()</tt> is not overloaded for <tt>X</tt> then the
-default (fully templated) version is used, which will call
-<tt>std::swap()</tt> (this means changing the current requirements for
-<tt>std::iter_swap()</tt>).
-
-<p>
-<Table border>
-  <tr>
-    <TH>Name</TH><TH>Expression</TH><TH>Return type</TH>
-  </tr>
-
-  <tr>
-    <td>Iterator Swap</td>
-    <td><tt>std::iter_swap(x, y)</tt></td>
-    <td>void</td>
-  </tr>
-
-  <tr>
-    <td>Dereference and Swap</td>
-    <td><tt>std::swap(*x, *y)</tt></td>
-    <td>void</td>
-  </tr>
-
-</table>
-
-<p>
-
-
-<hr>
-<!--------------------------------------------------------------------------->
-
-<H3><A NAME="concept:ConstantLvalueIterator"></A>
-Constant Lvalue Iterator
-</H3>
-
-A Constant Lvalue Iterator is an iterator that dereferences to produce a
-const reference to the pointed-to object, i.e., the associated
-<tt>reference</tt> type is <tt>const T&amp;</tt>. Changing the value
-of or destroying an iterator that models Constant Lvalue Iterator does
-not invalidate pointers and references previously obtained from that
-iterator.
-
- 
-<h3>Refinement of</h3>
-
-<a href="#concept:ReadableIterator">Readable Iterator</a> 
-
-<h3>Associated Types</h3>
-
-<Table border>
-
-  <tr>
-    <td>Reference type</td>
-    <td><tt>std::iterator_traits&lt;X&gt;::reference</tt></td>
-    <td>
-     The return type of dereferencing the iterator, which must be
-     <tt>const T&amp;</tt>.
-    </td>
-  </tr>
-
-<!--  I don't think this is needed
-  <tr>
-    <td>Pointer type</td>
-    <td><tt>std::iterator_traits&lt;X&gt;::pointer</tt></td>
-    <td>
-     The pointer to the value type, which must be <tt>const T*</tt>.
-    </td>
-  </tr>
--->
-
-  <tr>
-    <td>Return Category</td>
-    <td><tt>std::return_category&lt;X&gt;::type</tt></td>
-    <td>
-    A type convertible to <tt>std::constant_lvalue_iterator_tag</tt>
-    </td>
-  </tr>
-
-</table>
-
-<!-- these are not necessary now that we use reference as operator* return type
-<h3>Valid expressions</h3>
-
-<Table border>
-<tr><TH>Name</TH><TH>Expression</TH><TH>Type requirements</TH><TH>Return type</TH></tr>
-<tr>
- <td>Dereference</td>
- <td><tt>*x</tt></td>
- <td>&nbsp;</td>
- <td><tt>std::iterator_traits&lt;X&gt;::reference</tt></td>
-</tr>
-<tr>
- <td>Member access</td>
- <td><tt>x-&gt;m</tt></td>
- <td><tt>T</tt> is a type with a member named <tt>m</tt>.</td>
- <td>
- &nbsp;
- </td>
-</tr>
-</table>
-
--->
-
-<p>
-
-<hr>
-<!--------------------------------------------------------------------------->
-
-<H3><A NAME="concept:MutableLvalueIterator"></A>
-Mutable Lvalue Iterator
-</H3>
-
-A Mutable Lvalue Iterator is an iterator that dereferences to produce a
-reference to the pointed-to object. The associated <tt>reference</tt>
-type is <tt>T&amp;</tt>.  Changing the value of or destroying an
-iterator that models Mutable Lvalue Iterator does not invalidate
-pointers and references previously obtained from that iterator.
- 
-<h3>Refinement of</h3>
-
-<a href="#concept:ReadableIterator">Readable Iterator</a>,
-<a href="#concept:WritableIterator">Writable Iterator</a>,
-and <a href="#concept:SwappableIterator">Swappable Iterator</a>.
-
-
-
-<h3>Associated Types</h3>
-
-<Table border>
-
-  <tr>
-    <td>Reference type</td>
-    <td><tt>std::iterator_traits&lt;X&gt;::reference</tt></td>
-    <td>The return type of dereferencing the iterator, which must be
-     <tt>T&amp;</tt>.</td>
-  </tr>
-
-<!-- I don't think this is necessary
-  <tr>
-    <td>Pointer type</td>
-    <td><tt>std::iterator_traits&lt;X&gt;::pointer</tt></td>
-    <td>
-     The pointer to the value type, which is <tt>T*</tt>.
-    </td>
-  </tr>
--->
-
-  <tr>
-    <td>Return Category</td>
-    <td><tt>std::return_category&lt;X&gt;::type</tt></td>
-    <td>
-    A type convertible to <tt>std::mutable_lvalue_iterator_tag</tt>
-    </td>
-  </tr>
-
-</table>
-
-<!-- no longer needed since the return type is specified as reference in the readable iterator
-<h3>Valid expressions</h3>
-
-<Table border>
-<tr><TH>Name</TH><TH>Expression</TH><TH>Type requirements</TH><TH>Return type</TH></tr>
-<tr>
- <td>Dereference</td>
- <td><tt>*x</tt></td>
- <td>&nbsp;</td>
- <td><tt>std::iterator_traits&lt;X&gt;::reference</tt></td>
-</tr>
-<tr>
- <td>Member access</td>
- <td><tt>x-&gt;m</tt></td>
- <td><tt>T</tt> is a type with a member named <tt>m</tt>.</td>
- <td>
- &nbsp;
- </td>
-</tr>
-</table>
-
--->
-
-<p>
-<hr>
-<!--------------------------------------------------------------------------->
-
-<H3><A NAME="concept:ForwardTraversalIterator"></A>
-Forward Traversal Iterator
-</H3>
-
-The Forward Iterator is an iterator that can be incremented. Also, it
-is permissible to make multiple passes through the iterator's range.
-
-<h3>Refinement of</h3>
-
-<A href="http://www.boost.org/libs/utility/CopyConstructible.html">Copy Constructible</A>,
-<A href="http://www.boost.org/libs/utility/Assignable.html">Assignable</A>,
-<A href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</A>, and 
-<A href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</A>
-
-
-<h3>Associated types</h3>
-
-<Table border>
-
-  <tr>
-    <td>Difference Type</td>
-    <td><tt>std::iterator_traits&lt;X&gt;::difference_type</tt></td>
-    <td>
-    A signed integral type used for representing distances
-    between iterators that point into the same range.
-    </td>
-  </tr>
-
-  <tr>
-    <td>Traversal Category</td>
-    <td><tt>std::traversal_category&lt;X&gt;::type</tt></td>
-    <td>
-    A type convertible to <tt>std::forward_traversal_tag</tt>
-    </td>
-  </tr>
-</Table>
-
-<h3>Valid expressions</h3>
-
-<Table border>
-  <tr>
-    <TH>Name</TH><TH>Expression</TH><TH>Type requirements</TH>
-      <TH>Return type</TH>
-  </tr>
-  <tr>
-    <td>Preincrement</td>
-    <td><tt>++i</tt></td><td>&nbsp;</td><td><tt>X&amp;</tt></td>
-  </tr>
-  <tr>
-    <td>Postincrement</td>
-    <td><tt>i++</tt></td><td>&nbsp;</td><td>convertible to <tt>const X&amp;</tt></td>
-  </tr>
-</Table>
-
-<p>
-<hr>
-<!--------------------------------------------------------------------------->
-
-<H3><A NAME="concept:BidirectionalTraversalIterator"></A>
-Bidirectional Traversal Iterator
-</H3>
-
-An iterator that can be incremented and decremented.
-
-<h3>Refinement of</h3>
-
-<a href="#concept:ForwardTraversalIterator">Forward Traversal Iterator</a>
-
-<h3>Associated types</h3>
-
-<Table border>
-  <tr>
-    <td>Traversal Category</td>
-    <td><tt>std::traversal_category&lt;X&gt;::type</tt></td>
-    <td>
-    A type convertible to <tt>std::bidirectional_traversal_tag</tt>
-    </td>
-  </tr>
-</Table>
-
-<h3>Valid expressions</h3>
-
-<Table border>
-  <tr>
-  <TH>Name</TH><TH>Expression</TH><TH>Type requirements</TH>
-      <TH>Return type</TH>
-  </tr>
-  <tr><td>Predecrement</td>
-      <td><tt>--i</tt></td><td>&nbsp;</td><td><tt>X&amp;</tt></td>
-  </tr>
-  <tr><td>Postdecrement</td>
-      <td><tt>i--</tt></td><td>&nbsp;</td><td>convertible to <tt>const X&amp;</tt></td>
-  </tr>
-</table>
-
-<p>
-<hr>
-<!--------------------------------------------------------------------------->
-
-<H3><A NAME="concept:RandomAccessTraversalIterator"></A>
-Random Access Traversal Iterator
-</H3>
-
-An iterator that provides constant-time methods for moving forward and
-backward in arbitrary-sized steps.
-
-<h3>Refinement of</h3>
-
-<a href="#concept:BidirectionalTraversalIterator">Bidirectional Traversal Iterator</a> and
-<A href="http://www.sgi.com/tech/stl/LessThanComparable.html">Less Than Comparable</A> where <tt>&lt;</tt> is a total ordering
-
-<h3>Associated types</h3>
-
-<Table border>
-  <tr>
-    <td>Traversal Category</td>
-    <td><tt>std::traversal_category&lt;X&gt;::type</tt></td>
-    <td>
-    A type convertible to <tt>std::random_access_traversal_tag</tt>
-    </td>
-  </tr>
-</Table>
-
-<h3>Valid expressions</h3>
-
-<Table border>
-<tr><TH>Name</TH><TH>Expression</TH><TH>Type requirements</TH>
-    <TH>Return type</TH>
-</tr>
-<tr><td>Iterator addition</td>
-    <td><tt>i += n</tt></td><td>&nbsp;</td><td><tt>X&amp;</tt></td>
-</tr>
-<tr><td>Iterator addition</td>
-    <td><tt>i + n</tt> or <tt>n + i</tt></td><td>&nbsp;</td><td><tt>X</tt></td>
-</tr>
-<tr><td>Iterator subtraction</td>
-   <td><tt>i -= n</tt></td><td>&nbsp;</td><td><tt>X&amp;</tt></td>
-</tr>
-<tr><td>Iterator subtraction</td>
-    <td><tt>i - n</tt></td><td>&nbsp;</td><td><tt>X</tt></td>
-</tr>
-<tr><td>Difference</td>
-    <td><tt>i - j</tt></td><td>&nbsp;</td><td><tt>std::iterator_traits&lt;X&gt;::difference_type</tt></td>
-</tr>
-<tr><td>Element operator</td>
-    <td><tt>i[n]</tt></td>
-    <td><tt>X</tt> must also be a model of
-     <a href="#concept:ReadableIterator">Readable Iterator</a>. </td>
-    <td><tt>std::iterator_traits&lt;X&gt;::reference</tt></td>
-</tr>
-<tr><td>Element assignment</td>
-    <td><tt>i[n] = t</tt></td>
-    <td><tt>X</tt> must also be a model of
-      <a href="#concept:WritableIterator">Writable Iterator</a>.</td>
-    <td>unspecified</td>
-</tr>
-</table>
-
-<p>
-
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF="../../../../people/jeremy_siek.htm">Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
-</TD></TR></TABLE>
-
-</body>
-</html>

doc/facade-and-adaptor.html

@@ -26,7 +26,7 @@
 Lab</a>, <a class="last reference external" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
 <td>2006-09-11</td></tr>
-<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html">N1530</a>=03-0113, which was
+<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html">N1530</a>=03-0113, which was
 accepted for Technical Report 1 by the C++ standard
 committee's library working group.</td>
 </tr>
@@ -239,29 +239,29 @@ Iterator Concepts.</p>
 <div class="section" id="iterator-concepts">
 <h2><a class="toc-backref" href="#id18">Iterator Concepts</a></h2>
 <p>This proposal is formulated in terms of the new <tt class="docutils literal"><span class="pre">iterator</span> <span class="pre">concepts</span></tt>
-as proposed in <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>, since user-defined and especially adapted
+as proposed in <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>, since user-defined and especially adapted
 iterators suffer from the well known categorization problems that are
 inherent to the current iterator categories.</p>
-<p>This proposal does not strictly depend on proposal <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>, as there
+<p>This proposal does not strictly depend on proposal <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>, as there
 is a direct mapping between new and old categories. This proposal
-could be reformulated using this mapping if <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a> was not accepted.</p>
+could be reformulated using this mapping if <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a> was not accepted.</p>
 </div>
 <div class="section" id="interoperability">
 <h2><a class="toc-backref" href="#id19">Interoperability</a></h2>
 <p>The question of iterator interoperability is poorly addressed in the
 current standard.  There are currently two defect reports that are
 concerned with interoperability issues.</p>
-<p>Issue <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a> concerns the fact that mutable container iterator types
+<p>Issue <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a> concerns the fact that mutable container iterator types
 are only required to be convertible to the corresponding constant
 iterator types, but objects of these types are not required to
 interoperate in comparison or subtraction expressions.  This situation
 is tedious in practice and out of line with the way built in types
 work.  This proposal implements the proposed resolution to issue
-<a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>, as most standard library implementations do nowadays. In other
+<a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>, as most standard library implementations do nowadays. In other
 words, if an iterator type A has an implicit or user defined
 conversion to an iterator type B, the iterator types are interoperable
 and the usual set of operators are available.</p>
-<p>Issue <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280">280</a> concerns the current lack of interoperability between
+<p>Issue <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#280">280</a> concerns the current lack of interoperability between
 reverse iterator types. The proposed new reverse_iterator template
 fixes the issues raised in 280. It provides the desired
 interoperability without introducing unwanted overloads.</p>
@@ -422,8 +422,8 @@ member (e.g. <a class="reference internal" href="#counting"><tt class="docutils
 into the temporary iterator <tt class="docutils literal"><span class="pre">p+n</span></tt>, which is destroyed when
 <tt class="docutils literal"><span class="pre">operator[]</span></tt> returns.</p>
 <p>Writable iterators built with <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> implement the
-semantics required by the preferred resolution to <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
-adopted by proposal <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
+semantics required by the preferred resolution to <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
+adopted by proposal <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
 convertible to the iterator's <tt class="docutils literal"><span class="pre">value_type</span></tt>, and <tt class="docutils literal"><span class="pre">p[n]</span> <span class="pre">=</span> <span class="pre">x</span></tt> is
 equivalent to <tt class="docutils literal"><span class="pre">*(p</span> <span class="pre">+</span> <span class="pre">n)</span> <span class="pre">=</span> <span class="pre">x</span></tt> (Note: This result object may be
 implemented as a proxy containing a copy of <tt class="docutils literal"><span class="pre">p+n</span></tt>).  This approach

doc/facade-and-adaptor.rst

@@ -19,7 +19,7 @@
 .. Version 1.9 of this ReStructuredText document corresponds to
    n1530_, the paper accepted by the LWG.
 
-.. _n1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
+.. _n1530: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html
 
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
@@ -140,7 +140,7 @@ as proposed in n1550_, since user-defined and especially adapted
 iterators suffer from the well known categorization problems that are
 inherent to the current iterator categories.
 
-.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
+.. _n1550: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm
 
 This proposal does not strictly depend on proposal n1550_, as there
 is a direct mapping between new and old categories. This proposal
@@ -169,8 +169,8 @@ reverse iterator types. The proposed new reverse_iterator template
 fixes the issues raised in 280. It provides the desired
 interoperability without introducing unwanted overloads.
 
-.. _179: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179
-.. _280: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280
+.. _179: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179
+.. _280: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#280
 
 
 Iterator Facade

doc/function_input_iterator.rst

@@ -1,10 +1,13 @@
 :Author:
-    `Dean Michael Berris <mailto:mikhailberis@gmail.com>`_
+    `Dean Michael Berris <mailto:me@deanberris.com>`_
 
 :License:
     Distributed under the Boost Software License, Version 1.0
     (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+:Copyright:
+    Copyright 2012 Google, Inc.
+
 Function Input Iterator
 =======================
 
@@ -15,11 +18,14 @@ the iterator has been incremented. A Function Input Iterator models the
 
 .. _InputIterator: http://www.sgi.com/tech/stl/InputIterator.html
 
-Like the Generator Iterator, the Function Input Iterator takes a function
-that models the Generator_ concept (which is basically a nullary or 0-arity
-function object). Each increment of the function Function Input Iterator
-invokes the generator function and stores the value in the iterator. When
-the iterator is dereferenced the stored value is returned.
+The Function Input Iterator takes a function that models the Generator_ concept
+(which is basically a nullary or 0-arity function object). The first dereference
+of the iterator at a given position invokes the generator function and stores
+and returns the result; subsequent dereferences at the same position simply
+return the same stored result. Incrementing the iterator places it at a new
+position, hence a subsequent dereference will generate a new value via another
+invokation of the generator function. This ensures the generator function is
+invoked precisely when the iterator is requested to return a (new) value.
 
 .. _Generator: http://www.sgi.com/tech/stl/Generator.html
 
@@ -58,7 +64,7 @@ Synopsis
 
         template <class Function, class State>
         typename function_input_iterator<Function, State>
-        make_function_input_iterator(Function & f);
+        make_function_input_iterator(Function & f, State s);
 
         struct infinite;
     }
@@ -112,7 +118,7 @@ it with the ``boost::infinite`` helper class.
     copy(
             make_function_input_iterator(f,infinite()),
             make_function_input_iterator(f,infinite()),
-            ostream_iterator<int>(count, " ")
+            ostream_iterator<int>(cout, " ")
         );
    
 Above, instead of creating a huge vector we rely on the STL copy algorithm

doc/generator_iterator.htm

@@ -0,0 +1,163 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+<html>
+<head>
+  <meta http-equiv="Content-Language" content="en-us">
+  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
+
+  <title>Generator Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+  <img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle"
+  width="277" height="86">
+
+  <h1>Generator Iterator Adaptor</h1>
+
+  <p>Defined in header <a href=
+  "../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>
+
+  <p>The generator iterator adaptor makes it easier to create custom input
+  iterators from 0-ary functions and function objects. The adaptor takes a
+  <a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> and
+  creates a model of <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>. Each
+  increment retrieves an item from the generator and makes it available to be
+  retrieved by dereferencing. The motivation for this iterator is that some
+  concepts can be more naturally expressed as a generator, while most STL
+  algorithms expect an iterator. An example is the <a href=
+  "../random/index.html">Random Number</a> library.</p>
+
+  <h2>Synopsis</h2>
+
+  <blockquote>
+    <pre>
+namespace boost {
+  template &lt;class Generator&gt;
+  class generator_iterator_policies;
+
+  template &lt;class Generator&gt;
+  class generator_iterator_generator;
+
+  template &lt;class Generator&gt;
+  typename generator_iterator_generator&lt;Generator&gt;::type
+  make_generator_iterator(Generator &amp; gen);
+}
+</pre>
+  </blockquote>
+  <hr>
+
+  <h2>The Generator Iterator Generator Class</h2>
+
+  <p>The class generator_iterator_generator is a helper class whose purpose
+  is to construct a generator iterator type. The template parameter for this
+  class is the Generator function object type that is being wrapped. The
+  generator iterator adaptor only holds a reference (or pointer) to the
+  function object, therefore the function object must outlive the generator
+  iterator adaptor constructed from it.</p>
+  <pre>
+template &lt;class Generator&gt;
+class generator_iterator_generator
+{
+public:
+  typedef <i>unspecified</i> type; // the resulting generator iterator type 
+}
+</pre>
+
+  <h3>Template Parameters</h3>
+
+  <table border summary="">
+    <tr>
+      <th>Parameter</th>
+
+      <th>Description</th>
+    </tr>
+
+    <tr>
+      <td><tt><a href=
+      "http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>
+
+      <td>The generator (0-ary function object) type being wrapped. The
+      return type of the function must be defined as
+      <tt>Generator::result_type</tt>. The function object must be a model of
+      <a href=
+      "http://www.sgi.com/tech/stl/Generator.html">Generator</a>.</td>
+    </tr>
+  </table>
+
+  <h3>Concept Model</h3>
+
+  <p>The generator iterator class is a model of <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.</p>
+
+  <h3>Members</h3>
+
+  <p>The generator iterator implements the member functions and operators
+  required of the <a href=
+  "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
+  concept.<br></p>
+  <hr>
+
+  <h2><a name="make_generator_iterator" id="make_generator_iterator">The
+  Generator Iterator Object Generator</a></h2>
+
+  <p>The <tt>make_generator_iterator()</tt> function provides a convenient
+  way to create generator iterator objects. The function saves the user the
+  trouble of explicitly writing out the iterator types.</p>
+
+  <blockquote>
+    <pre>
+template &lt;class Generator&gt;
+typename generator_iterator_generator&lt;Generator&gt;::type
+make_generator_iterator(Generator &amp; gen);
+</pre>
+  </blockquote>
+  <hr>
+
+  <h3>Example</h3>
+
+  <p>The following program shows how <code>generator_iterator</code>
+  transforms a generator into an input iterator.</p>
+
+  <blockquote>
+    <pre>
+#include &lt;iostream&gt;
+#include &lt;boost/generator_iterator.hpp&gt;
+
+class my_generator
+{
+public:
+  typedef int result_type;
+  my_generator() : state(0) { }
+  int operator()() { return ++state; }
+private:
+  int state;
+};
+
+int main()
+{
+  my_generator gen;
+  boost::generator_iterator_generator&lt;my_generator&gt;::type it = boost::make_generator_iterator(gen);
+  for(int i = 0; i &lt; 10; ++i, ++it)
+    std::cout &lt;&lt; *it &lt;&lt; std::endl;
+}
+</pre>
+  </blockquote>
+  <hr>
+
+  <p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
+  "../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
+  height="31" width="88"></a></p>
+
+  <p>Revised 
+  <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
+
+  <p><i>Copyright &copy; 2001 <a href=
+  "http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a></i></p>
+
+  <p><i>Distributed under the Boost Software License, Version 1.0. (See
+  accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
+  copy at <a href=
+  "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
+</body>
+</html>

doc/issues.rst

@@ -3,7 +3,7 @@
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 .. _N1550: http://www.boost-consulting.com/writing/n1550.html
-.. _N1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
+.. _N1530: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html
 
 :Author: David Abrahams and Jeremy Siek
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu

doc/iterator_facade.html

@@ -242,8 +242,8 @@ member (e.g. <a class="reference external" href="counting_iterator.html"><tt cla
 into the temporary iterator <tt class="docutils literal"><span class="pre">p+n</span></tt>, which is destroyed when
 <tt class="docutils literal"><span class="pre">operator[]</span></tt> returns.</p>
 <p>Writable iterators built with <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> implement the
-semantics required by the preferred resolution to <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
-adopted by proposal <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
+semantics required by the preferred resolution to <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
+adopted by proposal <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm">n1550</a>: the result of <tt class="docutils literal"><span class="pre">p[n]</span></tt> is an object
 convertible to the iterator's <tt class="docutils literal"><span class="pre">value_type</span></tt>, and <tt class="docutils literal"><span class="pre">p[n]</span> <span class="pre">=</span> <span class="pre">x</span></tt> is
 equivalent to <tt class="docutils literal"><span class="pre">*(p</span> <span class="pre">+</span> <span class="pre">n)</span> <span class="pre">=</span> <span class="pre">x</span></tt> (Note: This result object may be
 implemented as a proxy containing a copy of <tt class="docutils literal"><span class="pre">p+n</span></tt>).  This approach

doc/iterator_facade_body.rst

@@ -167,9 +167,9 @@ the implementation of her iterator is free to implement an
 class; it will hide the one supplied by ``iterator_facade`` from
 clients of her iterator.
 
-.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
+.. _n1550: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm
 
-.. _`issue 299`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299
+.. _`issue 299`: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299
 
 .. _`operator arrow`:
 

doc/iterator_facade_ref.rst

@@ -106,7 +106,7 @@ The ``iterator_category`` member of ``iterator_facade`` is
 
 .. parsed-literal::
 
-  *iterator-category*\ (CategoryOrTraversal, value_type, reference)
+  *iterator-category*\ (CategoryOrTraversal, reference, value_type)
 
 where *iterator-category* is defined as follows:
 

doc/iterator_traits.html

@@ -3,11 +3,11 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.5: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.11: http://docutils.sourceforge.net/" />
 <title>Iterator Traits</title>
 <meta name="author" content="David Abrahams" />
 <meta name="organization" content="Boost Consulting" />
-<meta name="date" content="2006-09-11" />
+<meta name="date" content="$Date$" />
 <meta name="copyright" content="Copyright David Abrahams 2004." />
 <link rel="stylesheet" href="../../../rst.css" type="text/css" />
 </head>
@@ -25,7 +25,7 @@
 <tr><th class="docinfo-name">Organization:</th>
 <td><a class="first last reference external" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2006-09-11</td></tr>
+<td>$Date$</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
 <td>Copyright David Abrahams 2004.</td></tr>
 </tbody>
@@ -37,7 +37,7 @@
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">abstract:</th><td class="field-body">Header <tt class="docutils literal"><span class="pre">&lt;boost/iterator/iterator_traits.hpp&gt;</span></tt> provides
+<tr class="field"><th class="field-name">abstract:</th><td class="field-body">Header <tt class="docutils literal">&lt;boost/iterator/iterator_traits.hpp&gt;</tt> provides
 the ability to access an iterator's associated types using
 MPL-compatible <a class="reference external" href="../../mpl/doc/index.html#metafunctions">metafunctions</a>.</td>
 </tr>
@@ -46,15 +46,15 @@ MPL-compatible <a class="reference external" href="../../mpl/doc/index.html#meta
 <div class="section" id="overview">
 <h1>Overview</h1>
 <p><tt class="docutils literal"><span class="pre">std::iterator_traits</span></tt> provides access to five associated types
-of any iterator: its <tt class="docutils literal"><span class="pre">value_type</span></tt>, <tt class="docutils literal"><span class="pre">reference</span></tt>, <tt class="docutils literal"><span class="pre">pointer</span></tt>,
-<tt class="docutils literal"><span class="pre">iterator_category</span></tt>, and <tt class="docutils literal"><span class="pre">difference_type</span></tt>.  Unfortunately,
+of any iterator: its <tt class="docutils literal">value_type</tt>, <tt class="docutils literal">reference</tt>, <tt class="docutils literal">pointer</tt>,
+<tt class="docutils literal">iterator_category</tt>, and <tt class="docutils literal">difference_type</tt>.  Unfortunately,
 such a &quot;multi-valued&quot; traits template can be difficult to use in a
-metaprogramming context.  <tt class="docutils literal"><span class="pre">&lt;boost/iterator/iterator_traits.hpp&gt;</span></tt>
+metaprogramming context.  <tt class="docutils literal">&lt;boost/iterator/iterator_traits.hpp&gt;</tt>
 provides access to these types using a standard <a class="reference external" href="../../mpl/doc/index.html#metafunctions">metafunctions</a>.</p>
 </div>
 <div class="section" id="summary">
 <h1>Summary</h1>
-<p>Header <tt class="docutils literal"><span class="pre">&lt;boost/iterator/iterator_traits.hpp&gt;</span></tt>:</p>
+<p>Header <tt class="docutils literal">&lt;boost/iterator/iterator_traits.hpp&gt;</tt>:</p>
 <pre class="literal-block">
 template &lt;class Iterator&gt;
 struct iterator_value
@@ -98,21 +98,6 @@ struct iterator_category
 };
 </pre>
 </div>
-<div class="section" id="broken-compiler-notes">
-<h1>Broken Compiler Notes</h1>
-<p>Because of workarounds in Boost, you may find that these
-<a class="reference external" href="../../mpl/doc/index.html#metafunctions">metafunctions</a> actually work better than the facilities provided by
-your compiler's standard library.</p>
-<p>On compilers that don't support partial specialization, such as
-Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
-<a class="reference external" href="../../type_traits/index.html#transformations">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</a> on the
-<tt class="docutils literal"><span class="pre">value_type</span></tt> of pointers that are passed to these metafunctions.</p>
-<p>Because of bugs in the implementation of GCC-2.9x, the name of
-<tt class="docutils literal"><span class="pre">iterator_category</span></tt> is changed to <tt class="docutils literal"><span class="pre">iterator_category_</span></tt> on that
-compiler.  A macro, <tt class="docutils literal"><span class="pre">BOOST_ITERATOR_CATEGORY</span></tt>, that expands to
-either <tt class="docutils literal"><span class="pre">iterator_category</span></tt> or <tt class="docutils literal"><span class="pre">iterator_category_</span></tt>, as
-appropriate to the platform, is provided for portability.</p>
-</div>
 </div>
 <div class="footer">
 <hr class="footer" />

doc/iterator_traits.rst

@@ -75,24 +75,3 @@ Header ``<boost/iterator/iterator_traits.hpp>``::
         detail::iterator_traits<Iterator>::iterator_category
       type;
   };
-
-Broken Compiler Notes
-=====================
-
-Because of workarounds in Boost, you may find that these
-metafunctions_ actually work better than the facilities provided by
-your compiler's standard library.
-
-On compilers that don't support partial specialization, such as
-Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
-BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION_ on the
-``value_type`` of pointers that are passed to these metafunctions.
-
-Because of bugs in the implementation of GCC-2.9x, the name of
-``iterator_category`` is changed to ``iterator_category_`` on that
-compiler.  A macro, ``BOOST_ITERATOR_CATEGORY``, that expands to
-either ``iterator_category`` or ``iterator_category_``, as
-appropriate to the platform, is provided for portability.
-
-.. _BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION: ../../type_traits/index.html#transformations
-

doc/new-iter-concepts.html

@@ -27,10 +27,10 @@
 Lab</a>, <a class="last reference external" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
 <td>2006-09-11</td></tr>
-<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1550.html">n1550</a>=03-0133, which was
+<tr class="field"><th class="docinfo-name">Number:</th><td class="field-body">This is a revised version of <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1550.htm">n1550</a>=03-0133, which was
 accepted for Technical Report 1 by the C++ standard
 committee's library working group. This proposal is a
-revision of paper <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2001/n1297.html">n1297</a>, <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1477.html">n1477</a>, and <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1531.html">n1531</a>.</td>
+revision of paper <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2001/n1297.html">n1297</a>, <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1477.html">n1477</a>, and <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1531.html">n1531</a>.</td>
 </tr>
 <tr><th class="docinfo-name">Copyright:</th>
 <td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt
@@ -127,12 +127,12 @@ requirements in the iterator categories.</p>
 <td><tt class="docutils literal"><span class="pre">*i</span></tt> is convertible to <tt class="docutils literal"><span class="pre">T</span></tt></td>
 </tr>
 <tr><td>Forward Iterator</td>
-<td><tt class="docutils literal"><span class="pre">*i</span></tt> is <tt class="docutils literal"><span class="pre">T&amp;</span></tt> (or <tt class="docutils literal"><span class="pre">const</span> <span class="pre">T&amp;</span></tt> once <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 200</a>
+<td><tt class="docutils literal"><span class="pre">*i</span></tt> is <tt class="docutils literal"><span class="pre">T&amp;</span></tt> (or <tt class="docutils literal"><span class="pre">const</span> <span class="pre">T&amp;</span></tt> once <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#200">issue 200</a>
 is resolved)</td>
 </tr>
 <tr><td>Random Access Iterator</td>
 <td><tt class="docutils literal"><span class="pre">i[n]</span></tt> is convertible to <tt class="docutils literal"><span class="pre">T</span></tt> (also <tt class="docutils literal"><span class="pre">i[n]</span> <span class="pre">=</span> <span class="pre">t</span></tt>
-is required for mutable iterators once <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>
+is required for mutable iterators once <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>
 is resolved)</td>
 </tr>
 </tbody>
@@ -141,7 +141,7 @@ is resolved)</td>
 single hierarchy, many useful iterators can not be appropriately
 categorized. For example, <tt class="docutils literal"><span class="pre">vector&lt;bool&gt;::iterator</span></tt> is almost a
 random access iterator, but the return type is not <tt class="docutils literal"><span class="pre">bool&amp;</span></tt> (see
-<a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 96</a> and Herb Sutter's paper J16/99-0008 = WG21
+<a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#96">issue 96</a> and Herb Sutter's paper J16/99-0008 = WG21
 N1185). Therefore, the iterators of <tt class="docutils literal"><span class="pre">vector&lt;bool&gt;</span></tt> only meet the
 requirements of input iterator and output iterator.  This is so
 nonintuitive that the C++ standard contradicts itself on this point.
@@ -344,7 +344,7 @@ approach for specifying <tt class="docutils literal"><span class="pre">operator[
 direction would mean that an iterator satisfying the old Random Access
 Iterator requirements would not necessarily be a model of Readable or
 Writable Lvalue Iterator.  Instead we have chosen a design that
-matches the preferred resolution of <a class="reference external" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>: <tt class="docutils literal"><span class="pre">operator[]</span></tt> is
+matches the preferred resolution of <a class="reference external" href="http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#299">issue 299</a>: <tt class="docutils literal"><span class="pre">operator[]</span></tt> is
 only required to return something convertible to the <tt class="docutils literal"><span class="pre">value_type</span></tt>
 (for a Readable Iterator), and is required to support assignment
 <tt class="docutils literal"><span class="pre">i[n]</span> <span class="pre">=</span> <span class="pre">t</span></tt> (for a Writable Iterator).</p>
@@ -976,7 +976,7 @@ struct random_access_traversal_tag : bidirectional_traversal_tag { };
 <div class="section" id="addition-to-lib-iterator-traits">
 <h2><a class="toc-backref" href="#id23">Addition to [lib.iterator.traits]</a></h2>
 <p>The <tt class="docutils literal"><span class="pre">is_readable_iterator</span></tt> class
-template satisfies the <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">UnaryTypeTrait</a> requirements.</p>
+template satisfies the <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">UnaryTypeTrait</a> requirements.</p>
 <p>Given an iterator type <tt class="docutils literal"><span class="pre">X</span></tt>, <tt class="docutils literal"><span class="pre">is_readable_iterator&lt;X&gt;::value</span></tt>
 yields <tt class="docutils literal"><span class="pre">true</span></tt> if, for an object <tt class="docutils literal"><span class="pre">a</span></tt> of type <tt class="docutils literal"><span class="pre">X</span></tt>, <tt class="docutils literal"><span class="pre">*a</span></tt> is
 convertible to <tt class="docutils literal"><span class="pre">iterator_traits&lt;X&gt;::value_type</span></tt>, and <tt class="docutils literal"><span class="pre">false</span></tt>
@@ -1007,7 +1007,7 @@ otherwise.</p>
 </div>
 <div class="section" id="footnotes">
 <h1><a class="toc-backref" href="#id24">Footnotes</a></h1>
-<p>The UnaryTypeTrait concept is defined in <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">n1519</a>; the LWG is
+<p>The UnaryTypeTrait concept is defined in <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1519.htm">n1519</a>; the LWG is
 considering adding the requirement that specializations are derived
 from their nested <tt class="docutils literal"><span class="pre">::type</span></tt>.</p>
 <!-- LocalWords:  Abrahams Siek Witt const bool Sutter's WG int UL LI href Lvalue

doc/new-iter-concepts.rst

@@ -38,10 +38,10 @@
           
 .. contents:: Table of Contents
 
-.. _n1297: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2001/n1297.html
-.. _n1477: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1477.html
-.. _n1531: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1531.html
-.. _n1550: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1550.html
+.. _n1297: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2001/n1297.html
+.. _n1477: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1477.html
+.. _n1531: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1531.html
+.. _n1550: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1550.htm
 
 ============
  Motivation
@@ -76,8 +76,8 @@ requirements in the iterator categories.
 |                        |is resolved)                                         |
 +------------------------+-----------------------------------------------------+
 
-.. _issue 200: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#200
-.. _issue 299: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299
+.. _issue 200: http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#200
+.. _issue 299: http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#299
 
 
 Because iterator traversal and value access are mixed together in a
@@ -91,7 +91,7 @@ nonintuitive that the C++ standard contradicts itself on this point.
 In paragraph 23.2.4/1 it says that a ``vector`` is a sequence that
 supports random access iterators.
 
-.. _issue 96: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96
+.. _issue 96: http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#96
 
 Another difficult-to-categorize iterator is the transform iterator, an
 adaptor which applies a unary function object to the dereferenced
@@ -791,7 +791,7 @@ The UnaryTypeTrait concept is defined in n1519_; the LWG is
 considering adding the requirement that specializations are derived
 from their nested ``::type``.
 
-.. _n1519: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm
+.. _n1519: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1519.htm
 
 ..
  LocalWords:  Abrahams Siek Witt const bool Sutter's WG int UL LI href Lvalue

doc/quickbook/facade.qbk

@@ -165,9 +165,9 @@ the implementation of her iterator is free to implement an
 class; it will hide the one supplied by `iterator_facade` from
 clients of her iterator.
 
-.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
+.. _n1550: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2003/n1550.htm
 
-.. _`issue 299`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299
+.. _`issue 299`: http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#299
 
 .. _`operator arrow`:
 

doc/quickbook/traits.qbk

@@ -52,21 +52,4 @@ Header `<boost/iterator/iterator_traits.hpp>`:
       type;
   };
 
-[h2 Broken Compiler Notes]
-
-Because of workarounds in Boost, you may find that these
-[@../../mpl/doc/index.html#metafunctions metafunctions] actually work better than the facilities provided by
-your compiler's standard library.
-
-On compilers that don't support partial specialization, such as
-Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
-[@../../type_traits/index.html#transformations BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION] on the
-`value_type` of pointers that are passed to these metafunctions.
-
-Because of bugs in the implementation of GCC-2.9x, the name of
-`iterator_category` is changed to `iterator_category_` on that
-compiler.  A macro, `BOOST_ITERATOR_CATEGORY`, that expands to
-either `iterator_category` or `iterator_category_`, as
-appropriate to the platform, is provided for portability.
-
-[endsect]
+[endsect]

doc/quickbook/utilities.qbk

@@ -49,11 +49,40 @@ proxy references or return the pointee by value.  When that
 information is needed, call on `indirect_reference`.
 
 Both of these templates are essential to the correct functioning of
-[link indirecct `indirect_iterator`].
+[link boost_iterator.indirect `indirect_iterator`].
+
+[h2 `minimum_category`]
+
+`minimum_category` takes two iterator categories or two iterator traversal tags
+and returns the one that is the weakest (i.e. least advanced). For example:
+
+  static_assert(
+      is_same<
+          minimum_category<
+              std::forward_iterator_tag,
+              std::random_access_iterator_tag
+          >::type,
+          std::forward_iterator_tag
+      >::value,
+      "Unexpected minimum_category result"
+  );
+
+[h2 Iterator category and traversal tags manipulation]
+
+The library provides several utilities to simplify conversions between iterator categories
+and traversal tags:
+
+* `iterator_category_to_traversal<C>::type` - the metafunction takes an iterator category `C` and returns
+the corresponding traversal tag.
+* `iterator_traversal<T>::type` - a shorthand for `iterator_category_to_traversal<iterator_category<T>::type>::type`.
+* `pure_traversal_tag<T>::type` - the metafunction takes a tag `T` which derives from one of the iterator traversal tags
+and returns that traversal tag. `T` may also derive from other tags describing the iterator (e.g. whether this is a `const`-iterator
+or not), these additional tags are not considered.
+* `pure_iterator_traversal<T>::type` - a shorthand for `pure_traversal_tag<iterator_traversal<T>::type>::type`.
 
 [h2 Reference]
 
-[h3 `pointeee`]
+[h3 `pointee`]
 
   template <class Dereferenceable>
   struct pointee
@@ -110,6 +139,77 @@ Both of these templates are essential to the correct functioning of
   else
       std::iterator_traits<Dereferenceable>::reference
 
+[h3 `minimum_category`]
+
+  template <typename C1, typename C2>
+  struct minimum_category
+  {
+      typedef /* see below */ type;
+  };
+
+[*Requires:] Both `C1` and `C2` shall be standard iterator categories or
+  iterator traversal tags.
+
+`type` is determined according to the following algorithm, where `c1` is an
+object of type `C1` and `c2` is an object of type `C2`:
+
+  if (c1 is convertible to c2)
+      return C2;
+  else
+      return C1;
+
+[note The above definition relies on the fact that the more restricting categories
+and traversal tags are convertible to the less restricting ones.]
+
+[h3 `iterator_category_to_traversal`]
+
+  template <typename C>
+  struct iterator_category_to_traversal
+  {
+      typedef /* see below */ type;
+  };
+
+[*Requires:] `C` shall be a standard iterator category or an
+  iterator traversal tag.
+
+If `C` is an iterator traversal tag or convertible to one, `type` equivalent to `C`.
+Otherwise, `type` is defined to the closest iterator traversal tag matching `C`.
+
+[h3 `iterator_traversal`]
+
+  template <typename Iterator>
+  struct iterator_traversal
+  {
+      typedef typename iterator_category_to_traversal<
+          typename iterator_category<Iterator>::type
+      >::type type;
+  };
+
+[*Requires:] `Iterator` shall be an iterator.
+
+[h3 `pure_traversal_tag`]
+
+  template <typename T>
+  struct pure_traversal_tag
+  {
+      typedef /* see below */ type;
+  };
+
+[*Requires:] `T` shall be convertible to an iterator traversal tag.
+
+`type` is defined to be the most advanced traversal tag `Tag` so that `T` is convertible to `Tag`.
+
+[h3 `pure_iterator_traversal`]
+
+  template <typename Iterator>
+  struct pure_iterator_traversal
+  {
+      typedef typename pure_traversal_tag<
+          typename iterator_traversal<Iterator>::type
+      >::type type;
+  };
+
+[*Requires:] `Iterator` shall be an iterator.
 
 [endsect]
 
@@ -221,4 +321,4 @@ Iterator Traversal Concepts
 
 [endsect]
 
-[endsect]
+[endsect]

doc/ref_problem.rst

@@ -3,7 +3,7 @@
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 .. _N1550: http://www.boost-consulting.com/writing/n1550.html
-.. _N1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
+.. _N1530: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1530.html
 
 :Author: David Abrahams and Jeremy Siek
 :Contact: dave@boost-consulting.com, jsiek@osl.iu.edu

doc/transform_iterator.html

@@ -99,7 +99,7 @@ private:
 </pre>
 <p>If <tt class="docutils literal"><span class="pre">Reference</span></tt> is <tt class="docutils literal"><span class="pre">use_default</span></tt> then the <tt class="docutils literal"><span class="pre">reference</span></tt> member of
 <tt class="docutils literal"><span class="pre">transform_iterator</span></tt> is
-<tt class="docutils literal"><span class="pre">result_of&lt;UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.
+<tt class="docutils literal"><span class="pre">result_of&lt;const UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.
 Otherwise, <tt class="docutils literal"><span class="pre">reference</span></tt> is <tt class="docutils literal"><span class="pre">Reference</span></tt>.</p>
 <p>If <tt class="docutils literal"><span class="pre">Value</span></tt> is <tt class="docutils literal"><span class="pre">use_default</span></tt> then the <tt class="docutils literal"><span class="pre">value_type</span></tt> member is
 <tt class="docutils literal"><span class="pre">remove_cv&lt;remove_reference&lt;reference&gt;</span> <span class="pre">&gt;::type</span></tt>.  Otherwise,
@@ -117,10 +117,10 @@ convertible to <tt class="docutils literal"><span class="pre">input_iterator_tag
 <div class="section" id="transform-iterator-requirements">
 <h1><a class="toc-backref" href="#id3"><tt class="docutils literal"><span class="pre">transform_iterator</span></tt> requirements</a></h1>
 <p>The type <tt class="docutils literal"><span class="pre">UnaryFunction</span></tt> must be Assignable, Copy Constructible, and
-the expression <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be valid where <tt class="docutils literal"><span class="pre">f</span></tt> is an object of
+the expression <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be valid where <tt class="docutils literal"><span class="pre">f</span></tt> is a const object of
 type <tt class="docutils literal"><span class="pre">UnaryFunction</span></tt>, <tt class="docutils literal"><span class="pre">i</span></tt> is an object of type <tt class="docutils literal"><span class="pre">Iterator</span></tt>, and
 where the type of <tt class="docutils literal"><span class="pre">f(*i)</span></tt> must be
-<tt class="docutils literal"><span class="pre">result_of&lt;UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.</p>
+<tt class="docutils literal"><span class="pre">result_of&lt;const UnaryFunction(iterator_traits&lt;Iterator&gt;::reference)&gt;::type</span></tt>.</p>
 <p>The argument <tt class="docutils literal"><span class="pre">Iterator</span></tt> shall model Readable Iterator.</p>
 </div>
 <div class="section" id="transform-iterator-models">

doc/transform_iterator_ref.rst

@@ -41,7 +41,7 @@
 
 If ``Reference`` is ``use_default`` then the ``reference`` member of
 ``transform_iterator`` is
-``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
+``result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
 Otherwise, ``reference`` is ``Reference``.
 
 If ``Value`` is ``use_default`` then the ``value_type`` member is
@@ -64,10 +64,10 @@ convertible to ``input_iterator_tag``.
 ...................................
 
 The type ``UnaryFunction`` must be Assignable, Copy Constructible, and
-the expression ``f(*i)`` must be valid where ``f`` is an object of
+the expression ``f(*i)`` must be valid where ``f`` is a const object of
 type ``UnaryFunction``, ``i`` is an object of type ``Iterator``, and
 where the type of ``f(*i)`` must be
-``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
+``result_of<const UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
 
 The argument ``Iterator`` shall model Readable Iterator.  
 

include/boost/function_output_iterator.hpp

@@ -14,6 +14,7 @@
 #include <iterator>
 
 namespace boost {
+namespace iterators {
 
   template <class UnaryFunction>
   class function_output_iterator {
@@ -33,13 +34,13 @@ namespace boost {
     struct output_proxy {
       output_proxy(UnaryFunction& f) : m_f(f) { }
       template <class T> output_proxy& operator=(const T& value) {
-        m_f(value); 
-        return *this; 
+        m_f(value);
+        return *this;
       }
       UnaryFunction& m_f;
     };
     output_proxy operator*() { return output_proxy(m_f); }
-    self& operator++() { return *this; } 
+    self& operator++() { return *this; }
     self& operator++(int) { return *this; }
   private:
     UnaryFunction m_f;
@@ -51,6 +52,11 @@ namespace boost {
     return function_output_iterator<UnaryFunction>(f);
   }
 
+} // namespace iterators
+
+using iterators::function_output_iterator;
+using iterators::make_function_output_iterator;
+
 } // namespace boost
 
 #endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP

include/boost/generator_iterator.hpp

@@ -0,0 +1,85 @@
+// (C) Copyright Jens Maurer 2001.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Revision History:
+
+// 15 Nov 2001   Jens Maurer
+//      created.
+
+//  See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation.
+
+#ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+#define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/ref.hpp>
+
+namespace boost {
+namespace iterators {
+
+template<class Generator>
+class generator_iterator
+  : public iterator_facade<
+        generator_iterator<Generator>
+      , typename Generator::result_type
+      , single_pass_traversal_tag
+      , typename Generator::result_type const&
+    >
+{
+    typedef iterator_facade<
+        generator_iterator<Generator>
+      , typename Generator::result_type
+      , single_pass_traversal_tag
+      , typename Generator::result_type const&
+    > super_t;
+
+ public:
+    generator_iterator() {}
+    generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}
+
+    void increment()
+    {
+        m_value = (*m_g)();
+    }
+
+    const typename Generator::result_type&
+    dereference() const
+    {
+        return m_value;
+    }
+
+    bool equal(generator_iterator const& y) const
+    {
+        return this->m_g == y.m_g && this->m_value == y.m_value;
+    }
+
+ private:
+    Generator* m_g;
+    typename Generator::result_type m_value;
+};
+
+template<class Generator>
+struct generator_iterator_generator
+{
+  typedef generator_iterator<Generator> type;
+};
+
+template <class Generator>
+inline generator_iterator<Generator>
+make_generator_iterator(Generator & gen)
+{
+  typedef generator_iterator<Generator> result_t;
+  return result_t(&gen);
+}
+
+} // namespace iterators
+
+using iterators::generator_iterator;
+using iterators::generator_iterator_generator;
+using iterators::make_generator_iterator;
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP

include/boost/indirect_reference.hpp

@@ -0,0 +1,43 @@
+#ifndef INDIRECT_REFERENCE_DWA200415_HPP
+# define INDIRECT_REFERENCE_DWA200415_HPP
+
+//
+// Copyright David Abrahams 2004. Use, modification and distribution is
+// subject to the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// typename indirect_reference<P>::type provides the type of *p.
+//
+// http://www.boost.org/libs/iterator/doc/pointee.html
+//
+
+# include <boost/detail/is_incrementable.hpp>
+# include <boost/iterator/iterator_traits.hpp>
+# include <boost/type_traits/remove_cv.hpp>
+# include <boost/mpl/eval_if.hpp>
+# include <boost/pointee.hpp>
+
+namespace boost {
+
+namespace detail
+{
+  template <class P>
+  struct smart_ptr_reference
+  {
+      typedef typename boost::pointee<P>::type& type;
+  };
+}
+
+template <class P>
+struct indirect_reference
+  : mpl::eval_if<
+        detail::is_incrementable<P>
+      , iterator_reference<P>
+      , detail::smart_ptr_reference<P>
+    >
+{
+};
+
+} // namespace boost
+
+#endif // INDIRECT_REFERENCE_DWA200415_HPP

include/boost/iterator.hpp

@@ -1,59 +0,0 @@
-//  iterator.hpp workarounds for non-conforming standard libraries  ---------//
-
-//  (C) Copyright Beman Dawes 2000. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/utility for 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
-{
-# if defined(BOOST_NO_STD_ITERATOR) && !defined(BOOST_MSVC_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 : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
-# endif
-} // namespace boost
-
-#endif // BOOST_ITERATOR_HPP

include/boost/iterator/counting_iterator.hpp

@@ -13,6 +13,7 @@
 # include <boost/mpl/eval_if.hpp>
 
 namespace boost {
+namespace iterators {
 
 template <
     class Incrementable
@@ -30,13 +31,13 @@ namespace detail
   {
       // For a while, this wasn't true, but we rely on it below. This is a regression assert.
       BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
-      
+
 # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-      
+
       BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
-      
+
 # else
-      
+
 #  if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
       BOOST_STATIC_CONSTANT(
           bool, value = (
@@ -46,20 +47,20 @@ namespace detail
 #  else
     BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
 #  endif
-      
+
 # endif
   };
 
   template <class T>
   struct is_numeric
-    : mpl::bool_<(::boost::detail::is_numeric_impl<T>::value)>
+    : mpl::bool_<(::boost::iterators::detail::is_numeric_impl<T>::value)>
   {};
 
 #  if defined(BOOST_HAS_LONG_LONG)
   template <>
   struct is_numeric< ::boost::long_long_type>
     : mpl::true_ {};
-  
+
   template <>
   struct is_numeric< ::boost::ulong_long_type>
     : mpl::true_ {};
@@ -69,7 +70,7 @@ namespace detail
   template <>
   struct is_numeric<wchar_t>
     : mpl::true_ {};
-  
+
   template <class T>
   struct numeric_difference
   {
@@ -77,7 +78,7 @@ namespace detail
   };
 
   BOOST_STATIC_ASSERT(is_numeric<int>::value);
-  
+
   template <class Incrementable, class CategoryOrTraversal, class Difference>
   struct counting_iterator_base
   {
@@ -89,7 +90,7 @@ namespace detail
             , iterator_traversal<Incrementable>
           >
       >::type traversal;
-      
+
       typedef typename detail::ia_dflt_help<
           Difference
         , mpl::eval_if<
@@ -98,7 +99,7 @@ namespace detail
             , iterator_difference<Incrementable>
           >
       >::type difference;
-      
+
       typedef iterator_adaptor<
           counting_iterator<Incrementable, CategoryOrTraversal, Difference> // self
         , Incrementable                                           // Base
@@ -106,7 +107,7 @@ namespace detail
 # ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
           const  // MSVC won't strip this.  Instead we enable Thomas'
                  // criterion (see boost/iterator/detail/facade_iterator_category.hpp)
-# endif 
+# endif
         , traversal
         , Incrementable const&                                    // reference
         , difference
@@ -136,7 +137,7 @@ namespace detail
   {
       static Difference distance(Incrementable1 x, Incrementable2 y)
       {
-          return numeric_distance(x, y);
+          return boost::detail::numeric_distance(x, y);
       }
   };
 }
@@ -154,14 +155,14 @@ class counting_iterator
     typedef typename detail::counting_iterator_base<
         Incrementable, CategoryOrTraversal, Difference
     >::type super_t;
-    
+
     friend class iterator_core_access;
 
  public:
     typedef typename super_t::difference_type difference_type;
 
     counting_iterator() { }
-    
+
     counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {}
 
     counting_iterator(Incrementable x)
@@ -177,10 +178,10 @@ class counting_iterator
     )
       : super_t(t.base())
     {}
-# endif 
+# endif
 
  private:
-    
+
     typename super_t::reference dereference() const
     {
         return this->base_reference();
@@ -209,7 +210,11 @@ make_counting_iterator(Incrementable x)
   return result_t(x);
 }
 
+} // namespace iterators
 
-} // namespace boost::iterator
+using iterators::counting_iterator;
+using iterators::make_counting_iterator;
+
+} // namespace boost
 
 #endif // COUNTING_ITERATOR_DWA200348_HPP

include/boost/iterator/detail/any_conversion_eater.hpp

@@ -4,7 +4,9 @@
 #ifndef ANY_CONVERSION_EATER_DWA20031117_HPP
 # define ANY_CONVERSION_EATER_DWA20031117_HPP
 
-namespace boost { namespace detail {
+namespace boost {
+namespace iterators {
+namespace detail {
 
 // This type can be used in traits to "eat" up the one user-defined
 // implicit conversion allowed.
@@ -14,6 +16,6 @@ struct any_conversion_eater
     any_conversion_eater(T const&);
 };
 
-}} // namespace boost::detail
+}}} // namespace boost::iterators::detail
 
 #endif // ANY_CONVERSION_EATER_DWA20031117_HPP

include/boost/iterator/detail/config_def.hpp

@@ -46,8 +46,7 @@
 
 #endif
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                       \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                   \
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                      \
     || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
     || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
     || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
@@ -88,8 +87,7 @@
 #  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
 #endif
 
-#if BOOST_WORKAROUND(__GNUC__, == 2)                                                                            \
-    || BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
+#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
     || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 #  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
 
@@ -116,16 +114,9 @@
 # define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #endif 
 
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-#  define BOOST_ARG_DEPENDENT_TYPENAME typename
-# else
-#  define BOOST_ARG_DEPENDENT_TYPENAME
-# endif
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 
-# if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
-// GCC-2.95 eagerly instantiates templated constructors and conversion
+// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
 // operators in convertibility checks, causing premature errors.
 //
 // Borland's problems are harder to diagnose due to lack of an

include/boost/iterator/detail/config_undef.hpp

@@ -14,7 +14,6 @@
 #undef BOOST_NO_IS_CONVERTIBLE
 #undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
 #undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#undef BOOST_ARG_DEPENDENT_TYPENAME
 #undef BOOST_NO_LVALUE_RETURN_DETECTION
 #undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
 

include/boost/iterator/detail/enable_if.hpp

@@ -35,7 +35,7 @@ namespace boost
         typedef T type;
       };
     };
-    
+
     //
     // For compilers that don't support "Substitution Failure Is Not An Error"
     // enable_if falls back to always enabled. See comments
@@ -70,11 +70,8 @@ namespace boost
       : enabled<(Cond::value)>::template base<Return>
 # else
       : mpl::identity<Return>
-# endif 
+# endif
     {
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        typedef Return type;
-# endif 
     };
 
   } // namespace iterators

include/boost/iterator/detail/facade_iterator_category.hpp

@@ -30,10 +30,13 @@
 // iterator_category deduction for iterator_facade
 //
 
-// forward declaration
-namespace boost { struct use_default; }
+namespace boost {
+namespace iterators {
 
-namespace boost { namespace detail  {
+// forward declaration
+struct use_default;
+
+namespace detail {
 
 struct input_output_iterator_tag
   : std::input_iterator_tag
@@ -63,9 +66,9 @@ struct iterator_writability_disabled
       , boost::detail::indirect_traits::is_reference_to_const<Reference>
       , is_const<ValueParam>
     >
-# else 
+# else
   : is_const<ValueParam>
-# endif 
+# endif
 {};
 
 
@@ -73,16 +76,10 @@ struct iterator_writability_disabled
 // Convert an iterator_facade's traversal category, Value parameter,
 // and ::reference type to an appropriate old-style category.
 //
-// If writability has been disabled per the above metafunction, the
-// result will not be convertible to output_iterator_tag.
-//
-// Otherwise, if Traversal == single_pass_traversal_tag, the following
-// conditions will result in a tag that is convertible both to
-// input_iterator_tag and output_iterator_tag:
-//
-//    1. Reference is a reference to non-const
-//    2. Reference is not a reference and is convertible to Value
+// Due to changeset 21683, this now never results in a category convertible
+// to output_iterator_tag.
 //
+// Change at: https://svn.boost.org/trac/boost/changeset/21683
 template <class Traversal, class ValueParam, class Reference>
 struct iterator_facade_default_category
   : mpl::eval_if<
@@ -102,7 +99,7 @@ struct iterator_facade_default_category
       , typename mpl::eval_if<
             mpl::and_<
                 is_convertible<Traversal, single_pass_traversal_tag>
-                
+
                 // check for readability
               , is_convertible<Reference, ValueParam>
             >
@@ -138,7 +135,6 @@ template <class Category, class Traversal>
 struct iterator_category_with_traversal
   : Category, Traversal
 {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
     // Make sure this isn't used to build any categories where
     // convertibility to Traversal is redundant.  Should just use the
     // Category element in that case.
@@ -153,8 +149,7 @@ struct iterator_category_with_traversal
     BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
 #  if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
     BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
-#  endif 
-# endif 
+#  endif
 };
 
 // Computes an iterator_category tag whose traversal is Traversal and
@@ -162,14 +157,12 @@ struct iterator_category_with_traversal
 template <class Traversal, class ValueParam, class Reference>
 struct facade_iterator_category_impl
 {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
     BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
-# endif 
-    
+
     typedef typename iterator_facade_default_category<
         Traversal,ValueParam,Reference
     >::type category;
-    
+
     typedef typename mpl::if_<
         is_same<
             Traversal
@@ -193,7 +186,7 @@ struct facade_iterator_category
 {
 };
 
-}} // namespace boost::detail
+}}} // namespace boost::iterators::detail
 
 # include <boost/iterator/detail/config_undef.hpp>
 

include/boost/iterator/detail/minimum_category.hpp

@@ -4,113 +4,16 @@
 #ifndef MINIMUM_CATEGORY_DWA20031119_HPP
 # define MINIMUM_CATEGORY_DWA20031119_HPP
 
-# include <boost/type_traits/is_convertible.hpp>
-# include <boost/type_traits/is_same.hpp>
+# include <boost/iterator/minimum_category.hpp>
 
-# include <boost/mpl/aux_/lambda_support.hpp>
+namespace boost {
 
-namespace boost { namespace detail { 
-//
-// Returns the minimum category type or error_type
-// if T1 and T2 are unrelated.
-//
-// For compilers not supporting is_convertible this only
-// works with the new boost return and traversal category
-// types. The exact boost _types_ are required. No derived types
-// will work. 
-//
-//
-template <bool GreaterEqual, bool LessEqual>
-struct minimum_category_impl
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-{
-    template <class T1, class T2> struct apply
-    {
-        typedef T2 type;
-    };
-    typedef void type;
-}
-# endif 
-;
+// This import below (as well as the whole header) is for backward compatibility
+// with boost/token_iterator.hpp. It should be removed as soon as that header is fixed.
+namespace detail {
+using iterators::minimum_category;
+} // namespace detail
 
-template <class T1, class T2>
-struct error_not_related_by_convertibility;
-  
-template <>
-struct minimum_category_impl<true,false>
-{
-    template <class T1, class T2> struct apply
-    {
-        typedef T2 type;
-    };
-};
-
-template <>
-struct minimum_category_impl<false,true>
-{
-    template <class T1, class T2> struct apply
-    {
-        typedef T1 type;
-    };
-};
-
-template <>
-struct minimum_category_impl<true,true>
-{
-    template <class T1, class T2> struct apply
-    {
-        BOOST_STATIC_ASSERT((is_same<T1,T2>::value));
-        typedef T1 type;
-    };
-};
-
-template <>
-struct minimum_category_impl<false,false>
-{
-    template <class T1, class T2> struct apply
-    : error_not_related_by_convertibility<T1,T2>
-    {
-    };
-};
-
-template <class T1 = mpl::_1, class T2 = mpl::_2>
-struct minimum_category
-{
-    typedef minimum_category_impl< 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-        is_same<T2,int>::value ||
-# endif 
-        ::boost::is_convertible<T1,T2>::value
-      , ::boost::is_convertible<T2,T1>::value
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-        || is_same<T1,int>::value
-# endif 
-    > outer;
-
-    typedef typename outer::template apply<T1,T2> inner;
-    typedef typename inner::type type;
-      
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(2,minimum_category,(T1,T2))
-};
-    
-template <>
-struct minimum_category<mpl::_1,mpl::_2>
-{
-    template <class T1, class T2>
-    struct apply : minimum_category<T1,T2>
-    {};
-
-    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2))
-};
-
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-template <>
-struct minimum_category<int,int>
-{
-    typedef int type;
-};
-# endif
-    
-}} // namespace boost::detail
+} // namespace boost
 
 #endif // MINIMUM_CATEGORY_DWA20031119_HPP

include/boost/iterator/filter_iterator.hpp

@@ -14,8 +14,9 @@
 #include <boost/type_traits/is_class.hpp>
 #include <boost/static_assert.hpp>
 
-namespace boost
-{
+namespace boost {
+namespace iterators {
+
   template <class Predicate, class Iterator>
   class filter_iterator;
 
@@ -39,7 +40,7 @@ namespace boost
         > type;
     };
   }
-  
+
   template <class Predicate, class Iterator>
   class filter_iterator
     : public detail::filter_iterator_base<Predicate, Iterator>::type
@@ -68,7 +69,7 @@ namespace boost
           // Don't allow use of this constructor if Predicate is a
           // function pointer type, since it will be 0.
           BOOST_STATIC_ASSERT(is_class<Predicate>::value);
-#endif 
+#endif
           satisfy_predicate();
       }
 
@@ -108,28 +109,29 @@ namespace boost
   };
 
   template <class Predicate, class Iterator>
-  filter_iterator<Predicate,Iterator>
+  inline filter_iterator<Predicate,Iterator>
   make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
   {
       return filter_iterator<Predicate,Iterator>(f,x,end);
   }
 
   template <class Predicate, class Iterator>
-  filter_iterator<Predicate,Iterator>
+  inline filter_iterator<Predicate,Iterator>
   make_filter_iterator(
       typename iterators::enable_if<
           is_class<Predicate>
         , Iterator
       >::type x
-    , Iterator end = Iterator()
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    , Predicate* = 0
-#endif 
-  )
+    , Iterator end = Iterator())
   {
       return filter_iterator<Predicate,Iterator>(x,end);
   }
 
+} // namespace iterators
+
+using iterators::filter_iterator;
+using iterators::make_filter_iterator;
+
 } // namespace boost
 
 #endif // BOOST_FILTER_ITERATOR_23022003THW_HPP

include/boost/iterator/function_input_iterator.hpp

@@ -1,4 +1,6 @@
 // Copyright 2009 (C) Dean Michael Berris <me@deanberris.com>
+// Copyright 2012 (C) Google, Inc.
+// Copyright 2012 (C) Jeffrey Lee Hellrung, Jr.
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -7,14 +9,19 @@
 #ifndef BOOST_FUNCTION_INPUT_ITERATOR
 #define BOOST_FUNCTION_INPUT_ITERATOR
 
+#include <boost/assert.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/function_types/is_function_pointer.hpp>
 #include <boost/function_types/is_function_reference.hpp>
 #include <boost/function_types/result_type.hpp>
 #include <boost/iterator/iterator_facade.hpp>
+#include <boost/none.hpp>
+#include <boost/optional/optional.hpp>
 
 namespace boost {
 
+namespace iterators {
+
     namespace impl {
 
         template <class Function, class Input>
@@ -28,17 +35,20 @@ namespace boost {
         {
         public:
             function_input_iterator() {}
-            function_input_iterator(Function & f_, Input state_ = Input()) 
-                : f(&f_), state(state_), value((*f)()) {}
+            function_input_iterator(Function & f_, Input state_ = Input())
+                : f(&f_), state(state_) {}
 
             void increment() {
-                value = (*f)();
+                if(value)
+                    value = none;
+                else
+                    (*f)();
                 ++state;
             }
 
-            typename Function::result_type const & 
+            typename Function::result_type const &
                 dereference() const {
-                    return value;
+                    return (value ? value : value = (*f)()).get();
             }
 
             bool equal(function_input_iterator const & other) const {
@@ -48,7 +58,7 @@ namespace boost {
         private:
             Function * f;
             Input state;
-            typename Function::result_type value;
+            mutable optional<typename Function::result_type> value;
         };
 
         template <class Function, class Input>
@@ -63,17 +73,19 @@ namespace boost {
         public:
             function_pointer_input_iterator() {}
             function_pointer_input_iterator(Function &f_, Input state_ = Input())
-                : f(f_), state(state_), value((*f)()) 
-            {}
+                : f(f_), state(state_) {}
 
             void increment() {
-                value = (*f)();
+                if(value)
+                    value = none;
+                else
+                    (*f)();
                 ++state;
             }
 
             typename function_types::result_type<Function>::type const &
                 dereference() const {
-                    return value;
+                    return (value ? value : value = (*f)()).get();
             }
 
             bool equal(function_pointer_input_iterator const & other) const {
@@ -83,7 +95,7 @@ namespace boost {
         private:
             Function f;
             Input state;
-            typename function_types::result_type<Function>::type value;
+            mutable optional<typename function_types::result_type<Function>::type> value;
         };
 
         template <class Function, class Input>
@@ -99,7 +111,7 @@ namespace boost {
     } // namespace impl
 
     template <class Function, class Input>
-    class function_input_iterator 
+    class function_input_iterator
         : public mpl::if_<
             function_types::is_function_pointer<Function>,
             impl::function_pointer_input_iterator<Function,Input>,
@@ -144,7 +156,14 @@ namespace boost {
         bool operator==(infinite &) const { return false; };
         bool operator==(infinite const &) const { return false; };
     };
-}
+
+} // namespace iterators
+
+using iterators::function_input_iterator;
+using iterators::make_function_input_iterator;
+using iterators::infinite;
+
+} // namespace boost
 
 #endif
 

include/boost/iterator/indirect_iterator.hpp

@@ -30,12 +30,13 @@
 # include <boost/scoped_ptr.hpp>
 # include <boost/mpl/bool.hpp>
 # include <memory>
-#endif 
+#endif
 
 #include <boost/iterator/detail/config_def.hpp> // must be last #include
 
-namespace boost
-{
+namespace boost {
+namespace iterators {
+
   template <class Iter, class Value, class Category, class Reference, class Difference>
   class indirect_iterator;
 
@@ -44,8 +45,8 @@ namespace boost
     template <class Iter, class Value, class Category, class Reference, class Difference>
     struct indirect_base
     {
-        typedef typename iterator_traits<Iter>::value_type dereferenceable;
-        
+        typedef typename boost::detail::iterator_traits<Iter>::value_type dereferenceable;
+
         typedef iterator_adaptor<
             indirect_iterator<Iter, Value, Category, Reference, Difference>
           , Iter
@@ -69,7 +70,7 @@ namespace boost
     struct indirect_base<int, int, int, int, int> {};
   } // namespace detail
 
-    
+
   template <
       class Iterator
     , class Value = use_default
@@ -107,14 +108,14 @@ namespace boost
         : super_t(y.base())
       {}
 
-  private:    
+  private:
       typename super_t::reference dereference() const
       {
 # if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
           return const_cast<super_t::reference>(**this->base());
 # else
           return **this->base();
-# endif 
+# endif
       }
   };
 
@@ -132,6 +133,11 @@ namespace boost
     return indirect_iterator<Iter, Traits>(x);
   }
 
+} // namespace iterators
+
+using iterators::indirect_iterator;
+using iterators::make_indirect_iterator;
+
 } // namespace boost
 
 #include <boost/iterator/detail/config_undef.hpp>

include/boost/iterator/interoperable.hpp

@@ -14,8 +14,8 @@
 
 # include <boost/iterator/detail/config_def.hpp> // must appear last
 
-namespace boost
-{
+namespace boost {
+namespace iterators {
 
   //
   // Meta function that determines whether two
@@ -27,7 +27,7 @@ namespace boost
   // standards requirements on constant/mutable container
   // iterators (23.1 [lib.container.requirements]).
   //
-  // For compilers that don't support is_convertible 
+  // For compilers that don't support is_convertible
   // is_interoperable gives false positives. See comments
   // on operator implementation for consequences.
   //
@@ -40,9 +40,13 @@ namespace boost
           is_convertible< A, B >
         , is_convertible< B, A > >
 # endif
-  { 
+  {
   };
 
+} // namespace iterators
+
+using iterators::is_interoperable;
+
 } // namespace boost
 
 # include <boost/iterator/detail/config_undef.hpp>

include/boost/iterator/is_lvalue_iterator.hpp

@@ -18,7 +18,9 @@
 #ifndef BOOST_NO_IS_CONVERTIBLE
 
 namespace boost {
- 
+
+namespace iterators {
+
 namespace detail
 {
 #ifndef BOOST_NO_LVALUE_RETURN_DETECTION
@@ -26,20 +28,20 @@ namespace detail
   // to the expression's result if <expression> is an lvalue, or
   // not_an_lvalue() otherwise.
   struct not_an_lvalue {};
-  
+
   template <class T>
   T& lvalue_preserver(T&, int);
-  
+
   template <class U>
   not_an_lvalue lvalue_preserver(U const&, ...);
-  
+
 # define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0)
-  
+
 #else
-  
+
 # define BOOST_LVALUE_PRESERVER(expr) expr
-  
-#endif 
+
+#endif
 
   // Guts of is_lvalue_iterator.  Value is the iterator's value_type
   // and the result is computed in the nested rebind template.
@@ -55,12 +57,12 @@ namespace detail
 
       static char tester(conversion_eater, int);
       static char (& tester(any_conversion_eater, ...) )[2];
-    
+
       template <class It>
       struct rebind
       {
           static It& x;
-          
+
           BOOST_STATIC_CONSTANT(
               bool
             , value = (
@@ -75,7 +77,7 @@ namespace detail
   };
 
 #undef BOOST_LVALUE_PRESERVER
-  
+
   //
   // void specializations to handle std input and output iterators
   //
@@ -135,11 +137,16 @@ namespace detail
 // Define the trait with full mpl lambda capability and various broken
 // compiler workarounds
 BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_lvalue_iterator,T,::boost::detail::is_readable_lvalue_iterator_impl<T>::value)
-    
+    is_lvalue_iterator,T,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value)
+
 BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_non_const_lvalue_iterator,T,::boost::detail::is_non_const_lvalue_iterator_impl<T>::value)
-    
+    is_non_const_lvalue_iterator,T,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value)
+
+} // namespace iterators
+
+using iterators::is_lvalue_iterator;
+using iterators::is_non_const_lvalue_iterator;
+
 } // namespace boost
 
 #endif

include/boost/iterator/is_readable_iterator.hpp

@@ -16,7 +16,9 @@
 #ifndef BOOST_NO_IS_CONVERTIBLE
 
 namespace boost {
- 
+
+namespace iterators {
+
 namespace detail
 {
   // Guts of is_readable_iterator.  Value is the iterator's value_type
@@ -26,12 +28,12 @@ namespace detail
   {
       static char tester(Value&, int);
       static char (& tester(any_conversion_eater, ...) )[2];
-    
+
       template <class It>
       struct rebind
       {
           static It& x;
-          
+
           BOOST_STATIC_CONSTANT(
               bool
             , value = (
@@ -44,7 +46,7 @@ namespace detail
   };
 
 #undef BOOST_READABLE_PRESERVER
-  
+
   //
   // void specializations to handle std input and output iterators
   //
@@ -97,8 +99,12 @@ namespace detail
 // Define the trait with full mpl lambda capability and various broken
 // compiler workarounds
 BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_readable_iterator,T,::boost::detail::is_readable_iterator_impl2<T>::value)
-    
+    is_readable_iterator,T,::boost::iterators::detail::is_readable_iterator_impl2<T>::value)
+
+} // namespace iterators
+
+using iterators::is_readable_iterator;
+
 } // namespace boost
 
 #endif

include/boost/iterator/iterator_adaptor.hpp

@@ -31,28 +31,33 @@
 
 #include <boost/iterator/iterator_traits.hpp>
 
-namespace boost
-{
+namespace boost {
+namespace iterators {
+
   // Used as a default template argument internally, merely to
   // indicate "use the default", this can also be passed by users
   // explicitly in order to specify that the default should be used.
   struct use_default;
-  
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  // the incompleteness of use_default causes massive problems for
-  // is_convertible (naturally).  This workaround is fortunately not
-  // needed for vc6/vc7.
-  template<class To>
-  struct is_convertible<use_default,To>
-    : mpl::false_ {};
-# endif 
-  
+
+} // namespace iterators
+
+using iterators::use_default;
+
+// the incompleteness of use_default causes massive problems for
+// is_convertible (naturally).  This workaround is fortunately not
+// needed for vc6/vc7.
+template<class To>
+struct is_convertible<use_default,To>
+  : mpl::false_ {};
+
+namespace iterators {
+
   namespace detail
   {
 
-    // 
+    //
     // Result type used in enable_if_convertible meta function.
-    // This can be an incomplete type, as only pointers to 
+    // This can be an incomplete type, as only pointers to
     // enable_if_convertible< ... >::type are used.
     // We could have used void for this, but conversion to
     // void* is just to easy.
@@ -73,7 +78,7 @@ namespace boost
   //   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
   // {
   // public:
-  //   
+  //
   //   ...
   //
   //   template <class OtherIterator>
@@ -92,38 +97,23 @@ namespace boost
   // and not at the actual instantiation.
   //
   // enable_if_interoperable can be safely used in user code. It falls back to
-  // always enabled for compilers that don't support enable_if or is_convertible. 
-  // There is no need for compiler specific workarounds in user code. 
+  // always enabled for compilers that don't support enable_if or is_convertible.
+  // There is no need for compiler specific workarounds in user code.
   //
   // The operators implementation relies on boost::is_convertible not returning
   // false positives for user/library defined iterator types. See comments
   // on operator implementation for consequences.
   //
-#  if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-  
-  template<typename From, typename To>
-  struct enable_if_convertible
-  {
-     typedef typename mpl::if_<
-         mpl::or_<
-             is_same<From,To>
-           , is_convertible<From, To>
-         >
-      , boost::detail::enable_type
-      , int&
-     >::type type;
-  };
-  
-#  elif defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
-  
+#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
+
   template <class From, class To>
   struct enable_if_convertible
   {
-      typedef boost::detail::enable_type type;
+      typedef boost::iterators::detail::enable_type type;
   };
-  
-#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC > 1300
-  
+
+#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))
+
   // For some reason vc7.1 needs us to "cut off" instantiation
   // of is_convertible in a few cases.
   template<typename From, typename To>
@@ -133,22 +123,22 @@ namespace boost
             is_same<From,To>
           , is_convertible<From, To>
         >
-      , boost::detail::enable_type
+      , boost::iterators::detail::enable_type
     >
   {};
-  
-#  else 
-  
+
+#  else
+
   template<typename From, typename To>
   struct enable_if_convertible
     : iterators::enable_if<
           is_convertible<From, To>
-        , boost::detail::enable_type
+        , boost::iterators::detail::enable_type
       >
   {};
-      
+
 # endif
-  
+
   //
   // Default template argument handling for iterator_adaptor
   //
@@ -180,9 +170,9 @@ namespace boost
     {
         typedef iterator_facade<
             Derived
-            
+
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-          , typename boost::detail::ia_dflt_help<
+          , typename boost::iterators::detail::ia_dflt_help<
                 Value
               , mpl::eval_if<
                     is_same<Reference,use_default>
@@ -191,17 +181,17 @@ namespace boost
                 >
             >::type
 # else
-          , typename boost::detail::ia_dflt_help<
+          , typename boost::iterators::detail::ia_dflt_help<
                 Value, iterator_value<Base>
             >::type
 # endif
-            
-          , typename boost::detail::ia_dflt_help<
+
+          , typename boost::iterators::detail::ia_dflt_help<
                 Traversal
               , iterator_traversal<Base>
             >::type
 
-          , typename boost::detail::ia_dflt_help<
+          , typename boost::iterators::detail::ia_dflt_help<
                 Reference
               , mpl::eval_if<
                     is_same<Value,use_default>
@@ -210,13 +200,13 @@ namespace boost
                 >
             >::type
 
-          , typename boost::detail::ia_dflt_help<
+          , typename boost::iterators::detail::ia_dflt_help<
                 Difference, iterator_difference<Base>
             >::type
         >
         type;
     };
-  
+
     // workaround for aC++ CR JAGaf33512
     template <class Tr1, class Tr2>
     inline void iterator_adaptor_assert_traversal ()
@@ -224,7 +214,7 @@ namespace boost
       BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
     }
   }
-  
+
   //
   // Iterator Adaptor
   //
@@ -259,14 +249,14 @@ namespace boost
     , class Difference   = use_default
   >
   class iterator_adaptor
-    : public boost::detail::iterator_adaptor_base<
+    : public boost::iterators::detail::iterator_adaptor_base<
         Derived, Base, Value, Traversal, Reference, Difference
       >::type
   {
       friend class iterator_core_access;
 
    protected:
-      typedef typename boost::detail::iterator_adaptor_base<
+      typedef typename boost::iterators::detail::iterator_adaptor_base<
           Derived, Base, Value, Traversal, Reference, Difference
       >::type super_t;
    public:
@@ -285,7 +275,7 @@ namespace boost
    protected:
       // for convenience in derived classes
       typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
-      
+
       //
       // lvalue access to the Base object for Derived
       //
@@ -301,13 +291,13 @@ namespace boost
       // to prevent temptation for Derived classes to use it, which
       // will often result in an error.  Derived classes should use
       // base_reference(), above, to get direct access to m_iterator.
-      // 
+      //
       typename super_t::reference dereference() const
         { return *m_iterator; }
 
       template <
       class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
+      >
       bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
       {
         // Maybe readd with same_distance
@@ -322,17 +312,17 @@ namespace boost
       >::type my_traversal;
 
 # define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
-      boost::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
+      boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
 
       void advance(typename super_t::difference_type n)
       {
           BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
           m_iterator += n;
       }
-  
+
       void increment() { ++m_iterator; }
 
-      void decrement() 
+      void decrement()
       {
           BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)
            --m_iterator;
@@ -340,7 +330,7 @@ namespace boost
 
       template <
           class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
+      >
       typename super_t::difference_type distance_to(
           iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
       {
@@ -353,11 +343,16 @@ namespace boost
       }
 
 # undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL
-      
+
    private: // data members
       Base m_iterator;
   };
 
+} // namespace iterators
+
+using iterators::iterator_adaptor;
+using iterators::enable_if_convertible;
+
 } // namespace boost
 
 #include <boost/iterator/detail/config_undef.hpp>

include/boost/iterator/iterator_archetypes.hpp

@@ -20,7 +20,6 @@
 
 #include <boost/concept_archetype.hpp>
 
-#include <boost/mpl/aux_/msvc_eti_base.hpp>
 #include <boost/mpl/bitand.hpp>
 #include <boost/mpl/int.hpp>
 #include <boost/mpl/equal_to.hpp>
@@ -32,6 +31,7 @@
 #include <cstddef>
 
 namespace boost {
+namespace iterators {
 
 template <class Value, class AccessCategory>
 struct access_archetype;
@@ -39,7 +39,7 @@ struct access_archetype;
 template <class Derived, class Value, class AccessCategory, class TraversalCategory>
 struct traversal_archetype;
 
-namespace iterator_archetypes
+namespace archetypes
 {
   enum {
       readable_iterator_bit = 1
@@ -51,19 +51,19 @@ namespace iterator_archetypes
   // Not quite tags, since dispatching wouldn't work.
   typedef mpl::int_<readable_iterator_bit>::type readable_iterator_t;
   typedef mpl::int_<writable_iterator_bit>::type writable_iterator_t;
-  
+
   typedef mpl::int_<
       (readable_iterator_bit|writable_iterator_bit)
           >::type readable_writable_iterator_t;
-  
+
   typedef mpl::int_<
       (readable_iterator_bit|lvalue_iterator_bit)
           >::type readable_lvalue_iterator_t;
-  
+
   typedef mpl::int_<
       (lvalue_iterator_bit|writable_iterator_bit)
           >::type writable_lvalue_iterator_t;
-  
+
   typedef mpl::int_<swappable_iterator_bit>::type swappable_iterator_t;
   typedef mpl::int_<lvalue_iterator_bit>::type lvalue_iterator_t;
 
@@ -119,29 +119,27 @@ namespace detail
 
   template <class Value, class AccessCategory, class TraversalCategory>
   struct operator_brackets
-    : mpl::aux::msvc_eti_base<
-          typename mpl::eval_if<
-              is_convertible<TraversalCategory, random_access_traversal_tag>
-            , mpl::eval_if<
-                  iterator_archetypes::has_access<
-                      AccessCategory
-                    , iterator_archetypes::writable_iterator_t
-                  >
-                , mpl::identity<writable_operator_brackets<Value> >
-                , mpl::if_<
-                      iterator_archetypes::has_access<
-                          AccessCategory
-                        , iterator_archetypes::readable_iterator_t
-                      >
-                    , readable_operator_brackets<Value>
-                    , no_operator_brackets
-                  >
+    : mpl::eval_if<
+          is_convertible<TraversalCategory, random_access_traversal_tag>
+        , mpl::eval_if<
+              archetypes::has_access<
+                  AccessCategory
+                , archetypes::writable_iterator_t
               >
-            , mpl::identity<no_operator_brackets>
-          >::type
+            , mpl::identity<writable_operator_brackets<Value> >
+            , mpl::if_<
+                  archetypes::has_access<
+                      AccessCategory
+                    , archetypes::readable_iterator_t
+                  >
+                , readable_operator_brackets<Value>
+                , no_operator_brackets
+              >
+          >
+        , mpl::identity<no_operator_brackets>
       >::type
   {};
-  
+
   template <class TraversalCategory>
   struct traversal_archetype_impl
   {
@@ -154,18 +152,16 @@ namespace detail
 
   template <class Derived, class Value, class TraversalCategory>
   struct traversal_archetype_
-    : mpl::aux::msvc_eti_base<
-          typename traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
-      >::type
+    : traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
   {
       typedef typename
         traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
       base;
-      
+
       traversal_archetype_() {}
 
       traversal_archetype_(ctor_arg arg)
-        : base(arg) 
+        : base(arg)
       {}
   };
 
@@ -196,7 +192,7 @@ namespace detail
           explicit archetype(ctor_arg arg)
             : traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg)
           {}
-          
+
           typedef std::ptrdiff_t difference_type;
       };
   };
@@ -204,13 +200,7 @@ namespace detail
   template <class Derived, class Value>
   bool operator==(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
                   traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
-  
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-  // doesn't seem to pick up != from equality_comparable
-  template <class Derived, class Value>
-  bool operator!=(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
-                  traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
-#endif 
+
   template <>
   struct traversal_archetype_impl<forward_traversal_tag>
   {
@@ -218,7 +208,7 @@ namespace detail
       struct archetype
         : public traversal_archetype_<Derived, Value, single_pass_traversal_tag>
       {
-          archetype() 
+          archetype()
             : traversal_archetype_<Derived, Value, single_pass_traversal_tag>(ctor_arg())
           {}
       };
@@ -241,7 +231,7 @@ namespace detail
   {
       template<class Derived, class Value>
       struct archetype
-        : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag> 
+        : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag>
       {
           Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); }
           Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); }
@@ -300,7 +290,7 @@ namespace detail
 
 
 template <class> struct undefined;
-  
+
 template <class AccessCategory>
 struct iterator_access_archetype_impl
 {
@@ -309,17 +299,15 @@ struct iterator_access_archetype_impl
 
 template <class Value, class AccessCategory>
 struct iterator_access_archetype
-  : mpl::aux::msvc_eti_base<
-        typename iterator_access_archetype_impl<
-            AccessCategory
-        >::template archetype<Value>
-    >::type
+  : iterator_access_archetype_impl<
+        AccessCategory
+    >::template archetype<Value>
 {
 };
 
 template <>
 struct iterator_access_archetype_impl<
-    iterator_archetypes::readable_iterator_t
+    archetypes::readable_iterator_t
 >
 {
     template <class Value>
@@ -337,15 +325,13 @@ struct iterator_access_archetype_impl<
 
 template <>
 struct iterator_access_archetype_impl<
-    iterator_archetypes::writable_iterator_t
+    archetypes::writable_iterator_t
 >
 {
     template <class Value>
     struct archetype
     {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
         BOOST_STATIC_ASSERT(!is_const<Value>::value);
-# endif 
         typedef void value_type;
         typedef void reference;
         typedef void pointer;
@@ -356,13 +342,13 @@ struct iterator_access_archetype_impl<
 
 template <>
 struct iterator_access_archetype_impl<
-    iterator_archetypes::readable_writable_iterator_t
+    archetypes::readable_writable_iterator_t
 >
 {
     template <class Value>
     struct archetype
       : public virtual iterator_access_archetype<
-            Value, iterator_archetypes::readable_iterator_t
+            Value, archetypes::readable_iterator_t
         >
     {
         typedef detail::read_write_proxy<Value>    reference;
@@ -372,12 +358,12 @@ struct iterator_access_archetype_impl<
 };
 
 template <>
-struct iterator_access_archetype_impl<iterator_archetypes::readable_lvalue_iterator_t>
+struct iterator_access_archetype_impl<archetypes::readable_lvalue_iterator_t>
 {
     template <class Value>
     struct archetype
       : public virtual iterator_access_archetype<
-            Value, iterator_archetypes::readable_iterator_t
+            Value, archetypes::readable_iterator_t
         >
     {
         typedef Value&    reference;
@@ -386,28 +372,26 @@ struct iterator_access_archetype_impl<iterator_archetypes::readable_lvalue_itera
         Value* operator->() const { return 0; }
     };
 };
-  
+
 template <>
-struct iterator_access_archetype_impl<iterator_archetypes::writable_lvalue_iterator_t>
+struct iterator_access_archetype_impl<archetypes::writable_lvalue_iterator_t>
 {
     template <class Value>
     struct archetype
       : public virtual iterator_access_archetype<
-            Value, iterator_archetypes::readable_lvalue_iterator_t
+            Value, archetypes::readable_lvalue_iterator_t
         >
     {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
         BOOST_STATIC_ASSERT((!is_const<Value>::value));
-# endif 
     };
 };
-  
+
 
 template <class Value, class AccessCategory, class TraversalCategory>
 struct iterator_archetype;
-  
+
 template <class Value, class AccessCategory, class TraversalCategory>
-struct traversal_archetype_base 
+struct traversal_archetype_base
   : detail::operator_brackets<
         typename remove_cv<Value>::type
       , AccessCategory
@@ -429,12 +413,12 @@ namespace detail
     , traversal_archetype_base<Value, AccessCategory, TraversalCategory>
   {
       typedef iterator_access_archetype<Value, AccessCategory> access;
-      
+
       typedef typename detail::facade_iterator_category<
           TraversalCategory
         , typename mpl::eval_if<
-              iterator_archetypes::has_access<
-                  AccessCategory, iterator_archetypes::writable_iterator_t
+              archetypes::has_access<
+                  AccessCategory, archetypes::writable_iterator_t
               >
             , remove_const<Value>
             , add_const<Value>
@@ -467,18 +451,18 @@ struct iterator_archetype
   , public detail::iterator_archetype_base<
         Value, AccessCategory, TraversalCategory
     >::workaround_iterator_base
-# endif 
+# endif
 {
     // Derivation from std::iterator above caused references to nested
     // types to be ambiguous, so now we have to redeclare them all
     // here.
 # if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310)           \
     || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101))
-    
+
     typedef detail::iterator_archetype_base<
         Value,AccessCategory,TraversalCategory
     > base;
-    
+
     typedef typename base::value_type value_type;
     typedef typename base::reference reference;
     typedef typename base::pointer pointer;
@@ -509,7 +493,17 @@ struct iterator_archetype
 # endif
 };
 
+} // namespace iterators
+
+// Backward compatibility names
+namespace iterator_archetypes = iterators::archetypes;
+using iterators::access_archetype;
+using iterators::traversal_archetype;
+using iterators::iterator_archetype;
+using iterators::undefined;
+using iterators::iterator_access_archetype_impl;
+using iterators::traversal_archetype_base;
+
 } // namespace boost
 
-
 #endif // BOOST_ITERATOR_ARCHETYPES_HPP

include/boost/iterator/iterator_categories.hpp

@@ -22,6 +22,7 @@
 # include <boost/static_assert.hpp>
 
 namespace boost {
+namespace iterators {
 
 //
 // Traversal Categories
@@ -29,34 +30,34 @@ namespace boost {
 
 struct no_traversal_tag {};
 
-struct incrementable_traversal_tag 
+struct incrementable_traversal_tag
   : no_traversal_tag
 {
 //     incrementable_traversal_tag() {}
 //     incrementable_traversal_tag(std::output_iterator_tag const&) {};
 };
-  
+
 struct single_pass_traversal_tag
   : incrementable_traversal_tag
 {
 //     single_pass_traversal_tag() {}
 //     single_pass_traversal_tag(std::input_iterator_tag const&) {};
 };
-  
+
 struct forward_traversal_tag
   : single_pass_traversal_tag
 {
 //     forward_traversal_tag() {}
 //     forward_traversal_tag(std::forward_iterator_tag const&) {};
 };
-  
+
 struct bidirectional_traversal_tag
   : forward_traversal_tag
 {
 //     bidirectional_traversal_tag() {};
 //     bidirectional_traversal_tag(std::bidirectional_iterator_tag const&) {};
 };
-  
+
 struct random_access_traversal_tag
   : bidirectional_traversal_tag
 {
@@ -65,7 +66,7 @@ struct random_access_traversal_tag
 };
 
 namespace detail
-{  
+{
   //
   // Convert a "strictly old-style" iterator category to a traversal
   // tag.  This is broken out into a separate metafunction to reduce
@@ -97,51 +98,8 @@ namespace detail
       >
   {};
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-  template <>
-  struct old_category_to_traversal<int>
-  {
-      typedef int type;
-  };
-# endif
-
-  template <class Traversal>
-  struct pure_traversal_tag
-    : mpl::eval_if<
-          is_convertible<Traversal,random_access_traversal_tag>
-        , mpl::identity<random_access_traversal_tag>
-        , mpl::eval_if<
-              is_convertible<Traversal,bidirectional_traversal_tag>
-            , mpl::identity<bidirectional_traversal_tag>
-            , mpl::eval_if<
-                  is_convertible<Traversal,forward_traversal_tag>
-                , mpl::identity<forward_traversal_tag>
-                , mpl::eval_if<
-                      is_convertible<Traversal,single_pass_traversal_tag>
-                    , mpl::identity<single_pass_traversal_tag>
-                    , mpl::eval_if<
-                          is_convertible<Traversal,incrementable_traversal_tag>
-                        , mpl::identity<incrementable_traversal_tag>
-                        , void
-                      >
-                  >
-              >
-          >
-      >
-  {
-  };
-  
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-  template <>
-  struct pure_traversal_tag<int>
-  {
-      typedef int type;
-  };
-# endif
-
 } // namespace detail
 
-
 //
 // Convert an iterator category into a traversal tag
 //
@@ -150,7 +108,7 @@ struct iterator_category_to_traversal
   : mpl::eval_if< // if already convertible to a traversal tag, we're done.
         is_convertible<Cat,incrementable_traversal_tag>
       , mpl::identity<Cat>
-      , boost::detail::old_category_to_traversal<Cat>
+      , boost::iterators::detail::old_category_to_traversal<Cat>
     >
 {};
 
@@ -181,6 +139,82 @@ struct iterator_traversal<mpl::_>
 {};
 # endif
 
+//
+// Convert an iterator traversal to one of the traversal tags.
+//
+template <class Traversal>
+struct pure_traversal_tag
+  : mpl::eval_if<
+        is_convertible<Traversal,random_access_traversal_tag>
+      , mpl::identity<random_access_traversal_tag>
+      , mpl::eval_if<
+            is_convertible<Traversal,bidirectional_traversal_tag>
+          , mpl::identity<bidirectional_traversal_tag>
+          , mpl::eval_if<
+                is_convertible<Traversal,forward_traversal_tag>
+              , mpl::identity<forward_traversal_tag>
+              , mpl::eval_if<
+                    is_convertible<Traversal,single_pass_traversal_tag>
+                  , mpl::identity<single_pass_traversal_tag>
+                  , mpl::eval_if<
+                        is_convertible<Traversal,incrementable_traversal_tag>
+                      , mpl::identity<incrementable_traversal_tag>
+                      , void
+                    >
+                >
+            >
+        >
+    >
+{
+};
+
+// This import is needed for backward compatibility with Boost.Range:
+// boost/range/detail/demote_iterator_traversal_tag.hpp
+// It should be removed when that header is fixed.
+namespace detail {
+using iterators::pure_traversal_tag;
+} // namespace detail
+
+//
+// Trait to retrieve one of the iterator traversal tags from the iterator category or traversal.
+//
+template <class Iterator = mpl::_1>
+struct pure_iterator_traversal
+  : pure_traversal_tag<typename iterator_traversal<Iterator>::type>
+{};
+
+# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+template <>
+struct pure_iterator_traversal<mpl::_1>
+{
+    template <class T>
+    struct apply : pure_iterator_traversal<T>
+    {};
+};
+template <>
+struct pure_iterator_traversal<mpl::_>
+  : pure_iterator_traversal<mpl::_1>
+{};
+# endif
+
+} // namespace iterators
+
+using iterators::no_traversal_tag;
+using iterators::incrementable_traversal_tag;
+using iterators::single_pass_traversal_tag;
+using iterators::forward_traversal_tag;
+using iterators::bidirectional_traversal_tag;
+using iterators::random_access_traversal_tag;
+using iterators::iterator_category_to_traversal;
+using iterators::iterator_traversal;
+
+// This import is needed for backward compatibility with Boost.Range:
+// boost/range/detail/demote_iterator_traversal_tag.hpp
+// It should be removed when that header is fixed.
+namespace detail {
+using iterators::pure_traversal_tag;
+} // namespace detail
+
 } // namespace boost
 
 #include <boost/iterator/detail/config_undef.hpp>

include/boost/iterator/iterator_concepts.hpp

@@ -56,7 +56,7 @@ namespace boost_concepts
   private:
       Iterator i;
   };
-  
+
   template <
       typename Iterator
     , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
@@ -78,7 +78,7 @@ namespace boost_concepts
     , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
   >
   struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
-  
+
   BOOST_concept(SwappableIterator,(Iterator))
   {
       BOOST_CONCEPT_USAGE(SwappableIterator)
@@ -93,7 +93,7 @@ namespace boost_concepts
   BOOST_concept(LvalueIterator,(Iterator))
   {
       typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
-      
+
       BOOST_CONCEPT_USAGE(LvalueIterator)
       {
         value_type& r = const_cast<value_type&>(*i);
@@ -103,7 +103,7 @@ namespace boost_concepts
       Iterator i;
   };
 
-  
+
   //===========================================================================
   // Iterator Traversal Concepts
 
@@ -145,7 +145,7 @@ namespace boost_concepts
     , boost::DefaultConstructible<Iterator>
   {
       typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
-      
+
       BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
       BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
 
@@ -155,7 +155,7 @@ namespace boost_concepts
            , boost::forward_traversal_tag
           > ));
   };
-  
+
   BOOST_concept(BidirectionalTraversal,(Iterator))
     : ForwardTraversal<Iterator>
   {
@@ -192,14 +192,14 @@ namespace boost_concepts
           i = i - n;
           n = i - j;
       }
-      
+
    private:
       typename BidirectionalTraversal<Iterator>::difference_type n;
       Iterator i, j;
   };
 
   //===========================================================================
-  // Iterator Interoperability 
+  // Iterator Interoperability
 
   namespace detail
   {
@@ -248,19 +248,10 @@ namespace boost_concepts
   BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
   {
    private:
-      typedef typename boost::detail::pure_traversal_tag<
-          typename boost::iterator_traversal<
-              Iterator
-          >::type
-      >::type traversal_category;
+      typedef typename boost::iterators::pure_iterator_traversal<Iterator>::type traversal_category;
+      typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category;
 
-      typedef typename boost::detail::pure_traversal_tag<
-          typename boost::iterator_traversal<
-              ConstIterator
-          >::type
-      >::type const_traversal_category;
-      
-  public:
+   public:
       BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));
       BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));
 
@@ -271,7 +262,7 @@ namespace boost_concepts
 
           ci = i;
       }
-      
+
    private:
       Iterator      i;
       ConstIterator ci;