This commit was manufactured by cvs2svn to create tag

'Version_1_33_1'.

[SVN r31916]

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/BidirectionalTraversal.html

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Bidirectional Traversal Concept</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Bidirectional Traversal Concept</h1>
+<div class="document" id="bidirectional-traversal-concept">
+<p>A class or built-in type <tt class="literal"><span class="pre">X</span></tt> models the <em>Bidirectional Traversal</em>
+concept if, in addition to <tt class="literal"><span class="pre">X</span></tt> meeting the requirements of Forward
+Traversal Iterator, the following expressions are valid and respect
+the stated semantics.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="38%" />
+<col width="37%" />
+<col width="25%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th colspan="3">Bidirectional Traversal Iterator Requirements (in addition to Forward Traversal
+Iterator)</th>
+</tr>
+<tr><th>Expression</th>
+<th>Return Type</th>
+<th>Assertion/Semantics /
+Pre-/Post-condition</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="literal"><span class="pre">--r</span></tt></td>
+<td><tt class="literal"><span class="pre">X&amp;</span></tt></td>
+<td>pre: there exists
+<tt class="literal"><span class="pre">s</span></tt> such that <tt class="literal"><span class="pre">r</span>
+<span class="pre">==</span> <span class="pre">++s</span></tt>.  post:
+<tt class="literal"><span class="pre">s</span></tt> is
+dereferenceable.
+<tt class="literal"><span class="pre">--(++r)</span> <span class="pre">==</span> <span class="pre">r</span></tt>.
+<tt class="literal"><span class="pre">--r</span> <span class="pre">==</span> <span class="pre">--s</span></tt>
+implies <tt class="literal"><span class="pre">r</span> <span class="pre">==</span>
+<span class="pre">s</span></tt>. <tt class="literal"><span class="pre">&amp;r</span> <span class="pre">==</span> <span class="pre">&amp;--r</span></tt>.</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">r--</span></tt></td>
+<td>convertible to <tt class="literal"><span class="pre">const</span> <span class="pre">X&amp;</span></tt></td>
+<td><pre class="first last literal-block">
+{
+  X tmp = r;
+  --r;
+  return tmp;
+}
+</pre>
+</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">iterator_traversal&lt;X&gt;::type</span></tt></td>
+<td>Convertible to
+<tt class="literal"><span class="pre">bidirectional_traversal_tag</span></tt></td>
+<td>&nbsp;</td>
+</tr>
+</tbody>
+</table>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="BidirectionalTraversal.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/BidirectionalTraversal.rst

@@ -0,0 +1,37 @@
+Bidirectional Traversal Concept
+...............................
+
+A class or built-in type ``X`` models the *Bidirectional Traversal*
+concept if, in addition to ``X`` meeting the requirements of Forward
+Traversal Iterator, the following expressions are valid and respect
+the stated semantics.
+
++--------------------------------------------------------------------------------------+
+|Bidirectional Traversal Iterator Requirements (in addition to Forward Traversal       |
+|Iterator)                                                                             |
++--------------------------------+-------------------------------+---------------------+
+|Expression                      |Return Type                    |Assertion/Semantics /|
+|                                |                               |Pre-/Post-condition  |
++================================+===============================+=====================+
+|``--r``                         |``X&``                         |pre: there exists    |
+|                                |                               |``s`` such that ``r  |
+|                                |                               |== ++s``.  post:     |
+|                                |                               |``s`` is             |
+|                                |                               |dereferenceable.     |
+|                                |                               |``--(++r) == r``.    |
+|                                |                               |``--r == --s``       |
+|                                |                               |implies ``r ==       |
+|                                |                               |s``. ``&r == &--r``. |
++--------------------------------+-------------------------------+---------------------+
+|``r--``                         |convertible to ``const X&``    |::                   |
+|                                |                               |                     |
+|                                |                               | {                   |
+|                                |                               |   X tmp = r;        |
+|                                |                               |   --r;              |
+|                                |                               |   return tmp;       |
+|                                |                               | }                   |
++--------------------------------+-------------------------------+---------------------+
+|``iterator_traversal<X>::type`` |Convertible to                 |                     |
+|                                |``bidirectional_traversal_tag``|                     |
+|                                |                               |                     |
++--------------------------------+-------------------------------+---------------------+

doc/ForwardTraversal.html

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Forward Traversal Concept</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Forward Traversal Concept</h1>
+<div class="document" id="forward-traversal-concept">
+<p>A class or built-in type <tt class="literal"><span class="pre">X</span></tt> models the <em>Forward Traversal</em>
+concept if, in addition to <tt class="literal"><span class="pre">X</span></tt> meeting the requirements of Default
+Constructible and Single Pass Iterator, the following expressions are
+valid and respect the stated semantics.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="38%" />
+<col width="34%" />
+<col width="27%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th colspan="3">Forward Traversal Iterator Requirements (in addition to Default Constructible and Single Pass Iterator)</th>
+</tr>
+<tr><th>Expression</th>
+<th>Return Type</th>
+<th>Assertion/Note</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="literal"><span class="pre">X</span> <span class="pre">u;</span></tt></td>
+<td><tt class="literal"><span class="pre">X&amp;</span></tt></td>
+<td>note: <tt class="literal"><span class="pre">u</span></tt> may have a
+singular value.</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">++r</span></tt></td>
+<td><tt class="literal"><span class="pre">X&amp;</span></tt></td>
+<td><tt class="literal"><span class="pre">r</span> <span class="pre">==</span> <span class="pre">s</span></tt> and <tt class="literal"><span class="pre">r</span></tt> is
+dereferenceable implies
+<tt class="literal"><span class="pre">++r</span> <span class="pre">==</span> <span class="pre">++s.</span></tt></td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::difference_type</span></tt></td>
+<td>A signed integral type representing
+the distance between iterators</td>
+<td>&nbsp;</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">iterator_traversal&lt;X&gt;::type</span></tt></td>
+<td>Convertible to
+<tt class="literal"><span class="pre">forward_traversal_tag</span></tt></td>
+<td>&nbsp;</td>
+</tr>
+</tbody>
+</table>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="ForwardTraversal.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/ForwardTraversal.rst

@@ -0,0 +1,27 @@
+Forward Traversal Concept
+.........................
+
+A class or built-in type ``X`` models the *Forward Traversal*
+concept if, in addition to ``X`` meeting the requirements of Default
+Constructible and Single Pass Iterator, the following expressions are
+valid and respect the stated semantics.
+
++--------------------------------------------------------------------------------------------------------+
+|Forward Traversal Iterator Requirements (in addition to Default Constructible and Single Pass Iterator) |
++---------------------------------------+-----------------------------------+----------------------------+
+|Expression                             |Return Type                        |Assertion/Note              |
++=======================================+===================================+============================+
+|``X u;``                               |``X&``                             |note: ``u`` may have a      |
+|                                       |                                   |singular value.             |
++---------------------------------------+-----------------------------------+----------------------------+
+|``++r``                                |``X&``                             |``r == s`` and ``r`` is     |
+|                                       |                                   |dereferenceable implies     |
+|                                       |                                   |``++r == ++s.``             |
++---------------------------------------+-----------------------------------+----------------------------+
+|``iterator_traits<X>::difference_type``|A signed integral type representing|                            |
+|                                       |the distance between iterators     |                            |
+|                                       |                                   |                            |
++---------------------------------------+-----------------------------------+----------------------------+
+|``iterator_traversal<X>::type``        |Convertible to                     |                            |
+|                                       |``forward_traversal_tag``          |                            |
++---------------------------------------+-----------------------------------+----------------------------+

doc/GNUmakefile

@@ -1,232 +1,15 @@
-# GNUmakefile for postprocessing PDF files
-#
-# <EFBFBD> 2000 IBM Corporation.
-# Licensed under the GNU GPL.
+# Copyright David Abrahams 2004. 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)
 
-########################################################################
-# Make sure that the following macros are correct for your setup
-########################################################################
-# ... System utilities
-RMRF	= /bin/rm -rf
-MV	= /bin/mv
-EGREP	= /bin/egrep
 ECHO	= /bin/echo
-PERL	= /usr/bin/perl
-PYTHON	= python
-CAT	= /bin/cat
-TOUCH 	= /bin/touch
-ZIP	= /usr/bin/zip
 
-# ... TeX & postprocessors
-PPOWER4	      = ppower4
-PDFLATEX      = pdflatex
-METAPOST      = mpost
-FIG2DEV	      = fig2dev
-BIBTEX	      = bibtex
-FOLIAGECUTTER = foliageCutter --verbose
-RST2LATEX	  = rst2latex --documentclass book --documentoptions 10pt,twoside,pdftex # --use-latex-toc
-RST2HTML	  = rst2html
+all: 
+	@${ECHO} "<boost-root>/libs/iterator/doc/GNUmakefile should be replaced by"
+	@${ECHO}
+	@${ECHO} "    http://www.boost-consulting.com/writing/GNUmakefile,"
+	@${ECHO}
+	@${ECHO} "before proceeding.  That file is not included in the Boost"
+	@${ECHO} "distribution because it is licensed under the GPL, which violates"
+	@${ECHO} "Boost license requirements."
 
-TEX = latex
-export TEX
-########################################################################
-# End of user servicable parts; don't fiddle with the remainder of this
-# makefile unless you know what you do.
-#
-# You have been warned ;=)
-########################################################################
-
-# ... Variables
-TEXFILES = $(strip $(wildcard *.tex))
-RSTFILES = $(strip $(wildcard *.rst))
--include GNUmakefile.local
-TEXSTEMS = $(strip $(patsubst %.tex,%,${TEXFILES}))
-RSTSTEMS = $(strip $(patsubst %.rst,%,${RSTFILES}))
-CUTFOILS = $(strip $(patsubst %,%---toc.tex,${TEXSTEMS}))
-PDFFILES = $(strip $(patsubst %.tex,%.pdf,${TEXFILES}))
-PRINTS = $(patsubst %.pdf,%-print.pdf,${PDFFILES})
-PRINTZIP = prints.zip
-SLIDEZIP = slides.zip
-
-# ... Depend
-DEPENDFILES = .depend
-GENFILE	    = .generated
-
-# ... List of extensions and files generated
-texcrap = *.mpx *.log *.aux *.blg *-print.brf *-print.tex *.out
-
-mpxcrap = mpxerr.tex mpxerr.pdf
-
-generated = *.out *.[0-9] *.[0-9][0-9] *.bbl *.brf \
-	    *.mp *.mmp *.pdf *.ps TMP-*.pdf *.ftoc\
-	    ${PRINTZIP} ${SLIDEZIP} ${GENFILE} ${DEPENDFILES} \
-	    ${texcrap} ${mpxcrap} ${CUTFOILS} $(strip $(wildcard *---*.tex))
-
-
-# ... canned command to run PDFLaTeX
-define run-pdflatex
-@${ECHO} ""
-@${ECHO} "---- Running PDFLaTeX on $<" && ${PDFLATEX} $<
-@${ECHO} "---- Running PDFLaTeX on $< again" && ${PDFLATEX} $<
--@(${EGREP} -qi 'Rerun to get' $*.log && \
-		${ECHO} "---- Rerunning PDFLaTeX on $* to get cross-refs right" && \
-		${PDFLATEX} $<) || \
-		${ECHO} "---- No cross-refs correcting PDFLaTeX rerun required for $*"
--@(${EGREP} -qi $*.ftoc $*.log && \
-		${ECHO} "---- Rerunning PDFLaTeX on $* for FTOC" && \
-		${PDFLATEX} $<) || \
-		${ECHO} "---- No FTOC PDFLaTeX run required for $*"
--@(${EGREP} -qi 'Warning: Citation' $*.log && \
-		${ECHO} "---- Running BIBTeX on $*" && \
-		${BIBTEX} $* && \
-		${ECHO} "---- Running PDFLaTeX on $<" && \
-		${PDFLATEX} $<) || \
-		${ECHO} "---- No BIBTeX run required for $*"
--@(${EGREP} -qi 'Warning: .+undefined references' $*.log && \
-		${ECHO} "---- Running PDFLaTeX on $<" && \
-		${PDFLATEX} $<) || \
-		${ECHO} "---- No further PDFLaTex run required for $<"
-@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
-@${RMRF} ${texcrap}
-endef
-
-# ... canned command to run PDFLaTeX for printable versions
-define run-pdflatex-for-print
-@${ECHO} ""
-@${ECHO} "---- Running PDFLaTeX on $*-print.tex" && ${PDFLATEX} $*-print.tex
-@${ECHO} "---- Running PDFLaTeX on $< again" && ${PDFLATEX} $<
--@(${EGREP} -qi 'Warning: Citation' $*-print.log && \
-		${ECHO} "---- Running BIBTeX on $*-print" && \
-		${BIBTEX} $*-print && \
-		${ECHO} "---- Running PDFLaTeX on $*-print.tex" && \
-		${PDFLATEX} $*-print.tex) || \
-		${ECHO} "---- No BIBTeX run required for $*"
--@(${EGREP} -qi 'Warning: .+undefined references' $*-print.log && \
-		${ECHO} "---- Running PDFLaTeX on $*-print" && \
-		${PDFLATEX} $*-print.tex) || \
-		${ECHO} "---- No further PDFLaTex run required for $*-print"
-@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
-@${RMRF} ${texcrap}
-endef
-
-# DWA begin modifications
-# ... Rule: How to generate TeX from ReST
-%.tex: %.txt
-	@${ECHO} "---- Running rst2latex on $<"
-	${RST2LATEX} $< $@
-	@${ECHO} "Generated: $@ {$<}" >> ${GENFILE}
-
-# ... Rule: How to generate TeX from ReST
-%.tex: %.rst
-	@${ECHO} "---- Running rst2latex on $<"
-	${RST2LATEX} $< $@
-	@${ECHO} "Generated: $@ {$<}" >> ${GENFILE}
-
-# ... Rule: How to generate HTML from ReST
-%.html: %.txt
-	@${ECHO} "---- Running rst2html on $<"
-	${RST2HTML} $< $@
-	@${ECHO} "Generated: $@ {$<}" >> ${GENFILE}
-
-# ... Rule: How to generate HTML from ReST
-%.html: %.rst
-	@${ECHO} "---- Running rst2html on $<"
-	${RST2HTML} $< $@
-	@${ECHO} "Generated: $@ {$<}" >> ${GENFILE}
-# DWA end modifications
-
-# ... Rule: How to generate PDF from TeX
-%.pdf: %.tex
-	$(run-pdflatex)
-	@${MV} $@ TMP-$@
-	@${ECHO} "---- Running PPower4 on $*"
-	${PPOWER4} -v TMP-$@ $@
-	@${RMRF} TMP-$@
-	@${ECHO} "Postprocessed: $*.pdf {$*.pdf}" >> ${GENFILE}
-
-# ... Rule: How to generate printable PDF from TeX
-%-print.pdf: %.tex
-	${PERL} -pe 's/^\\documentclass\[(.*?)\]/\\documentclass\[$$1,prints\]/;' < $< > $*-print.tex
-	$(run-pdflatex-for-print)
-	@${ECHO} "Generated:     $*-print.pdf {$*.pdf}" >> ${GENFILE}
-
-# ... Rule: How to generate cut foils from TeX master
-%---toc.tex: %.tex
-	${FOLIAGECUTTER} --prefix=$* $<
-
-# ... Rule: How to generate MetaPost from FIG
-%.mp: %.fig
-	@${ECHO} "---- Running Fig2Dev (mp) on $<"
-	${FIG2DEV} -L mp $< $@
-	@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
-
-# ... Rule: How to generate MultiMetaPost from FIG
-%.mmp: %.fig
-	@${ECHO} "---- Running Fig2Dev (mmp) on $<"
-	${FIG2DEV} -L mmp $< $@
-	@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
-
-# ... Rule: How to generate includable PS from FIG via MetaPost
-%.mps: %.fig
-	@${ECHO} "---- Running Fig2Dev (mps) on $<"
-	${FIG2DEV} -L mp $< $*.mps.mp
-	@${RMRF} $*.mps.[0-9]
-	${METAPOST} $*.mps.mp
-	@${MV} $*.mps.0 $@
-	@${ECHO} "Generated:     $@ {$<}" >> ${GENFILE}
-
-# ... Rule: How to generate includable PS files from MultiMetaPost
-%.0: %.mmp
-	@${ECHO} "---- Running MetaPost on $<"
-	@${RMRF} $*.[0-9] $*.[0-9][0-9]
-	${METAPOST} $<
-	@${ECHO} "Generated:     $*.0{...} {$<}" >> ${GENFILE}
-
-cleanup-crap:
-	@${RMRF} ${mpxcrap}
-
-# ... Target: all
-all: cleanup-crap ${DEPENDFILES} ${PDFFILES} ${PRINTS} ${PRINTZIP} ${SLIDEZIP}
-	@${ECHO} ""
-	@${TOUCH} ${GENFILE}
-	@${CAT} ${GENFILE}
-	@${RMRF} ${GENFILE}
-
-# ... Target: ZIP files
-zip zips: ${PRINTZIP} ${SLIDEZIP}
-
-# ... Target: ZIP file containing printable versions of slides
-${PRINTZIP}: .depend ${PDFFILES}
-	@${RMRF} ${PRINTZIP}
-	${ZIP} -r ${PRINTZIP} ${PRINTS}
-	@${ECHO} "Generated:     ${PRINTZIP}" >> ${GENFILE}
-
-# ... Target: ZIP file containing screen versions of slides
- ${SLIDEZIP}: .depend ${PDFFILES}
-	@${RMRF} ${SLIDEZIP}
-	${ZIP} -r ${SLIDEZIP} ${PDFFILES}
-	@${ECHO} "Generated:     ${SLIDEZIP}" >> ${GENFILE}
-
-# ... Target: clean up
-clean:
-	${RMRF} ${generated}
-
-# ... Target: create dependencies
-depend: .depend
-
-# ... Target: dependency file (parse TEXFILES for multiinclude and includegraphics)
-# .depend: GNUmakefile ${TEXFILES}
-# 	${RMRF} $@
-# 	@for t in ${TEXSTEMS} ; do \
-# 		${ECHO} "Scanning $$t.tex"; \
-# 		${PERL} -e 'my $$target = shift @ARGV;' -e 'while (<>) { /\\multiinclude(\[.*?\])?{(.*?)}/ && print "$$target: $$2.0\n";}' $$t.pdf < $$t.tex >> $@; \
-# 		${PERL} -e 'my $$target = shift @ARGV;' -e 'while (<>) { /\\includegraphics(\[.*?\])?{(.*?)\.(.*?)}/ && print "$$target: $$2.$$3\n";}' $$t.pdf < $$t.tex >> $@; \
-# 	done
-
-.depend: GNUmakefile ${RSTFILES}
-	${RMRF} $@
-	${PYTHON} scanrst.py ${RSTFILES} > $@
-
-# ... include dependency files
-# -include .depend
--include .depend

doc/IncrementableIterator.html

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Incrementable Iterator Concept</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Incrementable Iterator Concept</h1>
+<div class="document" id="incrementable-iterator-concept">
+<p>A class or built-in type <tt class="literal"><span class="pre">X</span></tt> models the <em>Incrementable Iterator</em>
+concept if, in addition to <tt class="literal"><span class="pre">X</span></tt> being Assignable and Copy
+Constructible, the following expressions are valid and respect the
+stated semantics.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="39%" />
+<col width="37%" />
+<col width="24%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th colspan="3">Incrementable Iterator Requirements (in addition to Assignable, Copy Constructible)</th>
+</tr>
+<tr><th>Expression</th>
+<th>Return Type</th>
+<th>Assertion/Semantics</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="literal"><span class="pre">++r</span></tt></td>
+<td><tt class="literal"><span class="pre">X&amp;</span></tt></td>
+<td><tt class="literal"><span class="pre">&amp;r</span> <span class="pre">==</span> <span class="pre">&amp;++r</span></tt></td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">r++</span></tt></td>
+<td><tt class="literal"><span class="pre">X</span></tt></td>
+<td><pre class="first last literal-block">
+{
+   X tmp = r;
+   ++r;
+   return tmp;
+}
+</pre>
+</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">iterator_traversal&lt;X&gt;::type</span></tt></td>
+<td>Convertible to
+<tt class="literal"><span class="pre">incrementable_traversal_tag</span></tt></td>
+<td>&nbsp;</td>
+</tr>
+</tbody>
+</table>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="IncrementableIterator.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/IncrementableIterator.rst

@@ -0,0 +1,28 @@
+Incrementable Iterator Concept
+..............................
+
+A class or built-in type ``X`` models the *Incrementable Iterator*
+concept if, in addition to ``X`` being Assignable and Copy
+Constructible, the following expressions are valid and respect the
+stated semantics.
+
+
++-------------------------------------------------------------------------------------+
+|Incrementable Iterator Requirements (in addition to Assignable, Copy Constructible)  |
+|                                                                                     |
++--------------------------------+-------------------------------+--------------------+
+|Expression                      |Return Type                    |Assertion/Semantics |
++================================+===============================+====================+
+|``++r``                         |``X&``                         |``&r == &++r``      |
++--------------------------------+-------------------------------+--------------------+
+|``r++``                         |``X``                          |::                  |
+|                                |                               |                    |
+|                                |                               | {                  |
+|                                |                               |    X tmp = r;      |
+|                                |                               |    ++r;            |
+|                                |                               |    return tmp;     |
+|                                |                               | }                  |
++--------------------------------+-------------------------------+--------------------+
+|``iterator_traversal<X>::type`` |Convertible to                 |                    |
+|                                |``incrementable_traversal_tag``|                    |
++--------------------------------+-------------------------------+--------------------+

doc/InteroperableIterator.rst

@@ -0,0 +1,57 @@
+Interoperable Iterator Concept
+..............................
+
+A class or built-in type ``X`` that models Single Pass Iterator is
+*interoperable with* a class or built-in type ``Y`` that also models
+Single Pass Iterator if the following expressions are valid and
+respect the stated semantics. In the tables below, ``x`` is an object
+of type ``X``, ``y`` is an object of type ``Y``, ``Distance`` is
+``iterator_traits<Y>::difference_type``, and ``n`` represents a
+constant object of type ``Distance``.
+
++-----------+-----------------------+---------------------------------------------------+
+|Expression |Return Type            |Assertion/Precondition/Postcondition               |
++===========+=======================+===================================================+
+|``y = x``  |``Y``                  |post: ``y == x``                                   |
++-----------+-----------------------+---------------------------------------------------+
+|``Y(x)``   |``Y``                  |post: ``Y(x) == x``                                |
++-----------+-----------------------+---------------------------------------------------+
+|``x == y`` |convertible to ``bool``|``==`` is an equivalence relation over its domain. |
++-----------+-----------------------+---------------------------------------------------+
+|``y == x`` |convertible to ``bool``|``==`` is an equivalence relation over its domain. |
++-----------+-----------------------+---------------------------------------------------+
+|``x != y`` |convertible to ``bool``|``bool(a==b) != bool(a!=b)`` over its domain.      |
++-----------+-----------------------+---------------------------------------------------+
+|``y != x`` |convertible to ``bool``|``bool(a==b) != bool(a!=b)`` over its domain.      |
++-----------+-----------------------+---------------------------------------------------+
+
+If ``X`` and ``Y`` both model Random Access Traversal Iterator then
+the following additional requirements must be met.
+
++-----------+-----------------------+---------------------+--------------------------------------+
+|Expression |Return Type            |Operational Semantics|Assertion/ Precondition               |
++===========+=======================+=====================+======================================+
+|``x < y``  |convertible to ``bool``|``y - x > 0``        |``<`` is a total ordering relation    |
++-----------+-----------------------+---------------------+--------------------------------------+
+|``y < x``  |convertible to ``bool``|``x - y > 0``        |``<`` is a total ordering relation    |
++-----------+-----------------------+---------------------+--------------------------------------+
+|``x > y``  |convertible to ``bool``|``y < x``            |``>`` is a total ordering relation    |
++-----------+-----------------------+---------------------+--------------------------------------+
+|``y > x``  |convertible to ``bool``|``x < y``            |``>`` is a total ordering relation    |
++-----------+-----------------------+---------------------+--------------------------------------+
+|``x >= y`` |convertible to ``bool``|``!(x < y)``         |                                      |
++-----------+-----------------------+---------------------+--------------------------------------+
+|``y >= x`` |convertible to ``bool``|``!(y < x)``         |                                      |
++-----------+-----------------------+---------------------+--------------------------------------+
+|``x <= y`` |convertible to ``bool``|``!(x > y)``         |                                      |
++-----------+-----------------------+---------------------+--------------------------------------+
+|``y <= x`` |convertible to ``bool``|``!(y > x)``         |                                      |
++-----------+-----------------------+---------------------+--------------------------------------+
+|``y - x``  |``Distance``           |``distance(Y(x),y)`` |pre: there exists a value ``n`` of    |
+|           |                       |                     |``Distance`` such that ``x + n == y``.|
+|           |                       |                     |``y == x + (y - x)``.                 |
++-----------+-----------------------+---------------------+--------------------------------------+ 
+|``x - y``  |``Distance``           |``distance(y,Y(x))`` |pre: there exists a value ``n`` of    |
+|           |                       |                     |``Distance`` such that ``y + n == x``.|
+|           |                       |                     |``x == y + (x - y)``.                 |
++-----------+-----------------------+---------------------+--------------------------------------+

doc/LvalueIterator.html

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Lvalue Iterator Concept</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Lvalue Iterator Concept</h1>
+<div class="document" id="lvalue-iterator-concept">
+<p>The <em>Lvalue Iterator</em> concept adds the requirement that the return
+type of <tt class="literal"><span class="pre">operator*</span></tt> type be a reference to the value type of the
+iterator.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="22%" />
+<col width="19%" />
+<col width="59%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th colspan="3">Lvalue Iterator Requirements</th>
+</tr>
+<tr><th>Expression</th>
+<th>Return Type</th>
+<th>Note/Assertion</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="literal"><span class="pre">*a</span></tt></td>
+<td><tt class="literal"><span class="pre">T&amp;</span></tt></td>
+<td><tt class="literal"><span class="pre">T</span></tt> is <em>cv</em>
+<tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::value_type</span></tt>
+where <em>cv</em> is an optional
+cv-qualification.
+pre: <tt class="literal"><span class="pre">a</span></tt> is
+dereferenceable. If <tt class="literal"><span class="pre">a</span>
+<span class="pre">==</span> <span class="pre">b</span></tt> then <tt class="literal"><span class="pre">*a</span></tt> is
+equivalent to <tt class="literal"><span class="pre">*b</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="LvalueIterator.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/LvalueIterator.rst

@@ -0,0 +1,21 @@
+Lvalue Iterator Concept
+.......................
+
+The *Lvalue Iterator* concept adds the requirement that the return
+type of ``operator*`` type be a reference to the value type of the
+iterator.
+
++-------------------------------------------------------------+
+| Lvalue Iterator Requirements                                |
++-------------+-----------+-----------------------------------+
+|Expression   |Return Type|Note/Assertion                     |
++=============+===========+===================================+
+|``*a``       | ``T&``    |``T`` is *cv*                      |
+|             |           |``iterator_traits<X>::value_type`` |
+|             |           |where *cv* is an optional          |
+|             |           |cv-qualification.                  |
+|             |           |pre: ``a`` is                      |
+|             |           |dereferenceable. If ``a            |
+|             |           |== b`` then ``*a`` is              |
+|             |           |equivalent to ``*b``.              |
++-------------+-----------+-----------------------------------+

doc/RandomAccessTraversal.html

@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Random Access Traversal Concept</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Random Access Traversal Concept</h1>
+<div class="document" id="random-access-traversal-concept">
+<p>A class or built-in type <tt class="literal"><span class="pre">X</span></tt> models the <em>Random Access Traversal</em>
+concept if the following expressions are valid and respect the stated
+semantics.  In the table below, <tt class="literal"><span class="pre">Distance</span></tt> is
+<tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::difference_type</span></tt> and <tt class="literal"><span class="pre">n</span></tt> represents a
+constant object of type <tt class="literal"><span class="pre">Distance</span></tt>.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="28%" />
+<col width="30%" />
+<col width="23%" />
+<col width="20%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th colspan="4">Random Access Traversal Iterator Requirements (in addition to Bidirectional Traversal)</th>
+</tr>
+<tr><th>Expression</th>
+<th>Return Type</th>
+<th>Operational Semantics</th>
+<th>Assertion/
+Precondition</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="literal"><span class="pre">r</span> <span class="pre">+=</span> <span class="pre">n</span></tt></td>
+<td><tt class="literal"><span class="pre">X&amp;</span></tt></td>
+<td><pre class="first last literal-block">
+{
+  Distance m = n;
+  if (m &gt;= 0)
+    while (m--)
+      ++r;
+  else
+    while (m++)
+      --r;
+  return r;
+}
+</pre>
+</td>
+<td>&nbsp;</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a</span> <span class="pre">+</span> <span class="pre">n</span></tt>, <tt class="literal"><span class="pre">n</span> <span class="pre">+</span> <span class="pre">a</span></tt></td>
+<td><tt class="literal"><span class="pre">X</span></tt></td>
+<td><tt class="literal"><span class="pre">{</span> <span class="pre">X</span> <span class="pre">tmp</span> <span class="pre">=</span> <span class="pre">a;</span> <span class="pre">return</span> <span class="pre">tmp</span>
+<span class="pre">+=</span> <span class="pre">n;</span> <span class="pre">}</span></tt></td>
+<td>&nbsp;</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">r</span> <span class="pre">-=</span> <span class="pre">n</span></tt></td>
+<td><tt class="literal"><span class="pre">X&amp;</span></tt></td>
+<td><tt class="literal"><span class="pre">return</span> <span class="pre">r</span> <span class="pre">+=</span> <span class="pre">-n</span></tt></td>
+<td>&nbsp;</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a</span> <span class="pre">-</span> <span class="pre">n</span></tt></td>
+<td><tt class="literal"><span class="pre">X</span></tt></td>
+<td><tt class="literal"><span class="pre">{</span> <span class="pre">X</span> <span class="pre">tmp</span> <span class="pre">=</span> <span class="pre">a;</span> <span class="pre">return</span> <span class="pre">tmp</span>
+<span class="pre">-=</span> <span class="pre">n;</span> <span class="pre">}</span></tt></td>
+<td>&nbsp;</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">b</span> <span class="pre">-</span> <span class="pre">a</span></tt></td>
+<td><tt class="literal"><span class="pre">Distance</span></tt></td>
+<td><tt class="literal"><span class="pre">a</span> <span class="pre">&lt;</span> <span class="pre">b</span> <span class="pre">?</span>&nbsp; <span class="pre">distance(a,b)</span>
+<span class="pre">:</span> <span class="pre">-distance(b,a)</span></tt></td>
+<td>pre: there exists a
+value <tt class="literal"><span class="pre">n</span></tt> of
+<tt class="literal"><span class="pre">Distance</span></tt> such that
+<tt class="literal"><span class="pre">a</span> <span class="pre">+</span> <span class="pre">n</span> <span class="pre">==</span> <span class="pre">b</span></tt>.  <tt class="literal"><span class="pre">b</span>
+<span class="pre">==</span> <span class="pre">a</span> <span class="pre">+</span> <span class="pre">(b</span> <span class="pre">-</span> <span class="pre">a)</span></tt>.</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a[n]</span></tt></td>
+<td>convertible to T</td>
+<td><tt class="literal"><span class="pre">*(a</span> <span class="pre">+</span> <span class="pre">n)</span></tt></td>
+<td>pre: a is a <em>Readable
+Iterator</em></td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a[n]</span> <span class="pre">=</span> <span class="pre">v</span></tt></td>
+<td>convertible to T</td>
+<td><tt class="literal"><span class="pre">*(a</span> <span class="pre">+</span> <span class="pre">n)</span> <span class="pre">=</span> <span class="pre">v</span></tt></td>
+<td>pre: a is a <em>Writable
+iterator</em></td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a</span> <span class="pre">&lt;</span> <span class="pre">b</span></tt></td>
+<td>convertible to <tt class="literal"><span class="pre">bool</span></tt></td>
+<td><tt class="literal"><span class="pre">b</span> <span class="pre">-</span> <span class="pre">a</span> <span class="pre">&gt;</span> <span class="pre">0</span></tt></td>
+<td><tt class="literal"><span class="pre">&lt;</span></tt> is a total
+ordering relation</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a</span> <span class="pre">&gt;</span> <span class="pre">b</span></tt></td>
+<td>convertible to <tt class="literal"><span class="pre">bool</span></tt></td>
+<td><tt class="literal"><span class="pre">b</span> <span class="pre">&lt;</span> <span class="pre">a</span></tt></td>
+<td><tt class="literal"><span class="pre">&gt;</span></tt> is a total
+ordering relation</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a</span> <span class="pre">&gt;=</span> <span class="pre">b</span></tt></td>
+<td>convertible to <tt class="literal"><span class="pre">bool</span></tt></td>
+<td><tt class="literal"><span class="pre">!(a</span> <span class="pre">&lt;</span> <span class="pre">b)</span></tt></td>
+<td>&nbsp;</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a</span> <span class="pre">&lt;=</span> <span class="pre">b</span></tt></td>
+<td>convertible to <tt class="literal"><span class="pre">bool</span></tt></td>
+<td><tt class="literal"><span class="pre">!(a</span> <span class="pre">&gt;</span> <span class="pre">b)</span></tt></td>
+<td>&nbsp;</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">iterator_traversal&lt;X&gt;::type</span></tt></td>
+<td>Convertible to
+<tt class="literal"><span class="pre">random_access_traversal_tag</span></tt></td>
+<td>&nbsp;</td>
+<td>&nbsp;</td>
+</tr>
+</tbody>
+</table>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="RandomAccessTraversal.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/RandomAccessTraversal.rst

@@ -0,0 +1,63 @@
+Random Access Traversal Concept
+...............................
+
+A class or built-in type ``X`` models the *Random Access Traversal*
+concept if the following expressions are valid and respect the stated
+semantics.  In the table below, ``Distance`` is
+``iterator_traits<X>::difference_type`` and ``n`` represents a
+constant object of type ``Distance``.
+
++------------------------------------------------------------------------------------------------------------------+
+|Random Access Traversal Iterator Requirements (in addition to Bidirectional Traversal)                            |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|Expression                     |Return Type                      |Operational Semantics    |Assertion/            |
+|                               |                                 |                         |Precondition          |
++===============================+=================================+=========================+======================+
+|``r += n``                     |``X&``                           |::                       |                      |
+|                               |                                 |                         |                      |
+|                               |                                 | {                       |                      |
+|                               |                                 |   Distance m = n;       |                      |
+|                               |                                 |   if (m >= 0)           |                      |
+|                               |                                 |     while (m--)         |                      |
+|                               |                                 |       ++r;              |                      |
+|                               |                                 |   else                  |                      |
+|                               |                                 |     while (m++)         |                      |
+|                               |                                 |       --r;              |                      |
+|                               |                                 |   return r;             |                      |
+|                               |                                 | }                       |                      |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``a + n``, ``n + a``           |``X``                            |``{ X tmp = a; return tmp|                      |
+|                               |                                 |+= n; }``                |                      |
+|                               |                                 |                         |                      |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``r -= n``                     |``X&``                           |``return r += -n``       |                      |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``a - n``                      |``X``                            |``{ X tmp = a; return tmp|                      |
+|                               |                                 |-= n; }``                |                      |
+|                               |                                 |                         |                      |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``b - a``                      |``Distance``                     |``a < b ?  distance(a,b) |pre: there exists a   |
+|                               |                                 |: -distance(b,a)``       |value ``n`` of        |
+|                               |                                 |                         |``Distance`` such that|
+|                               |                                 |                         |``a + n == b``.  ``b  |
+|                               |                                 |                         |== a + (b - a)``.     |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``a[n]``                       |convertible to T                 |``*(a + n)``             |pre: a is a *Readable |
+|                               |                                 |                         |Iterator*             |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``a[n] = v``                   |convertible to T                 |``*(a + n) = v``         |pre: a is a *Writable |
+|                               |                                 |                         |iterator*             |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``a < b``                      |convertible to ``bool``          |``b - a > 0``            |``<`` is a total      |
+|                               |                                 |                         |ordering relation     |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``a > b``                      |convertible to ``bool``          |``b < a``                |``>`` is a total      |
+|                               |                                 |                         |ordering relation     |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``a >= b``                     |convertible to ``bool``          |``!(a < b)``             |                      |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``a <= b``                     |convertible to ``bool``          |``!(a > b)``             |                      |
++-------------------------------+---------------------------------+-------------------------+----------------------+
+|``iterator_traversal<X>::type``|Convertible to                   |                         |                      |
+|                               |``random_access_traversal_tag``  |                         |                      |
++-------------------------------+---------------------------------+-------------------------+----------------------+

doc/ReadableIterator.html

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Readable Iterator Concept</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Readable Iterator Concept</h1>
+<div class="document" id="readable-iterator-concept">
+<p>A class or built-in type <tt class="literal"><span class="pre">X</span></tt> models the <em>Readable Iterator</em> concept
+for value type <tt class="literal"><span class="pre">T</span></tt> if, in addition to <tt class="literal"><span class="pre">X</span></tt> being Assignable and
+Copy Constructible, the following expressions are valid and respect
+the stated semantics. <tt class="literal"><span class="pre">U</span></tt> is the type of any specified member of
+type <tt class="literal"><span class="pre">T</span></tt>.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="28%" />
+<col width="20%" />
+<col width="52%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th colspan="3">Readable Iterator Requirements (in addition to Assignable and Copy Constructible)</th>
+</tr>
+<tr><th>Expression</th>
+<th>Return Type</th>
+<th>Note/Precondition</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::value_type</span></tt></td>
+<td><tt class="literal"><span class="pre">T</span></tt></td>
+<td>Any non-reference,
+non-cv-qualified type</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">*a</span></tt></td>
+<td>Convertible to <tt class="literal"><span class="pre">T</span></tt></td>
+<td><dl class="first last">
+<dt>pre: <tt class="literal"><span class="pre">a</span></tt> is dereferenceable. If <tt class="literal"><span class="pre">a</span> <span class="pre">==</span> <span class="pre">b</span></tt> then <tt class="literal"><span class="pre">*a</span></tt></dt>
+<dd>is equivalent to <tt class="literal"><span class="pre">*b</span></tt>.</dd>
+</dl>
+</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a-&gt;m</span></tt></td>
+<td><tt class="literal"><span class="pre">U&amp;</span></tt></td>
+<td>pre: <tt class="literal"><span class="pre">pre:</span> <span class="pre">(*a).m</span></tt> is well-defined. Equivalent to <tt class="literal"><span class="pre">(*a).m</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="ReadableIterator.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/ReadableIterator.rst

@@ -0,0 +1,23 @@
+
+Readable Iterator Concept
+.........................
+
+A class or built-in type ``X`` models the *Readable Iterator* concept
+for value type ``T`` if, in addition to ``X`` being Assignable and
+Copy Constructible, the following expressions are valid and respect
+the stated semantics. ``U`` is the type of any specified member of
+type ``T``.
+
++-----------------------------------------------------------------------------------------------------------------------------+
+|Readable Iterator Requirements (in addition to Assignable and Copy Constructible)                                            |
++-----------------------------------+------------------------+----------------------------------------------------------------+
+|Expression                         |Return Type             |Note/Precondition                                               |
++===================================+========================+================================================================+
+|``iterator_traits<X>::value_type`` |``T``                   |Any non-reference,                                              |
+|                                   |                        |non-cv-qualified type                                           |
++-----------------------------------+------------------------+----------------------------------------------------------------+
+|``*a``                             | Convertible to ``T``   |pre: ``a`` is dereferenceable. If ``a == b`` then ``*a``        |
+|                                   |                        | is equivalent to ``*b``.                                       |
++-----------------------------------+------------------------+----------------------------------------------------------------+
+|``a->m``                           |``U&``                  |pre: ``pre: (*a).m`` is well-defined. Equivalent to ``(*a).m``. |
++-----------------------------------+------------------------+----------------------------------------------------------------+

doc/SinglePassIterator.html

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Single Pass Iterator Concept</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Single Pass Iterator Concept</h1>
+<div class="document" id="single-pass-iterator-concept">
+<p>A class or built-in type <tt class="literal"><span class="pre">X</span></tt> models the <em>Single Pass Iterator</em>
+concept if the following expressions are valid and respect the stated
+semantics.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="36%" />
+<col width="33%" />
+<col width="31%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th colspan="3">Single Pass Iterator Requirements (in addition to Incrementable Iterator and Equality
+Comparable)</th>
+</tr>
+<tr><th>Expression</th>
+<th>Return Type</th>
+<th>Assertion/Semantics /
+Pre-/Post-condition</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="literal"><span class="pre">++r</span></tt></td>
+<td><tt class="literal"><span class="pre">X&amp;</span></tt></td>
+<td>pre: <tt class="literal"><span class="pre">r</span></tt> is
+dereferenceable; post:
+<tt class="literal"><span class="pre">r</span></tt> is dereferenceable or
+<tt class="literal"><span class="pre">r</span></tt> is past-the-end</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a</span> <span class="pre">==</span> <span class="pre">b</span></tt></td>
+<td>convertible to <tt class="literal"><span class="pre">bool</span></tt></td>
+<td><tt class="literal"><span class="pre">==</span></tt> is an equivalence
+relation over its domain</td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">a</span> <span class="pre">!=</span> <span class="pre">b</span></tt></td>
+<td>convertible to <tt class="literal"><span class="pre">bool</span></tt></td>
+<td><tt class="literal"><span class="pre">!(a</span> <span class="pre">==</span> <span class="pre">b)</span></tt></td>
+</tr>
+<tr><td><tt class="literal"><span class="pre">iterator_traversal&lt;X&gt;::type</span></tt></td>
+<td>Convertible to
+<tt class="literal"><span class="pre">single_pass_traversal_tag</span></tt></td>
+<td>&nbsp;</td>
+</tr>
+</tbody>
+</table>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="SinglePassIterator.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/SinglePassIterator.rst

@@ -0,0 +1,28 @@
+Single Pass Iterator Concept
+............................
+
+A class or built-in type ``X`` models the *Single Pass Iterator*
+concept if the following expressions are valid and respect the stated
+semantics.
+
+
++------------------------------------------------------------------------------------------+
+|Single Pass Iterator Requirements (in addition to Incrementable Iterator and Equality     |
+|Comparable)                                                                               |
++--------------------------------+-----------------------------+---------------------------+
+|Expression                      |Return Type                  |Assertion/Semantics /      | 
+|                                |                             |Pre-/Post-condition        |
++================================+=============================+===========================+
+|``++r``                         |``X&``                       |pre: ``r`` is              |
+|                                |                             |dereferenceable; post:     |
+|                                |                             |``r`` is dereferenceable or|
+|                                |                             |``r`` is past-the-end      |
++--------------------------------+-----------------------------+---------------------------+
+|``a == b``                      |convertible to ``bool``      |``==`` is an equivalence   |
+|                                |                             |relation over its domain   |
++--------------------------------+-----------------------------+---------------------------+
+|``a != b``                      |convertible to ``bool``      |``!(a == b)``              |
++--------------------------------+-----------------------------+---------------------------+
+|``iterator_traversal<X>::type`` |Convertible to               |                           |
+|                                |``single_pass_traversal_tag``|                           |
++--------------------------------+-----------------------------+---------------------------+

doc/SwappableIterator.html

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Swappable Iterator Concept</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Swappable Iterator Concept</h1>
+<div class="document" id="swappable-iterator-concept">
+<p>A class or built-in type <tt class="literal"><span class="pre">X</span></tt> models the <em>Swappable Iterator</em> concept
+if, in addition to <tt class="literal"><span class="pre">X</span></tt> being Copy Constructible, the following
+expressions are valid and respect the stated semantics.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="37%" />
+<col width="19%" />
+<col width="43%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th colspan="3">Swappable Iterator Requirements (in addition to Copy Constructible)</th>
+</tr>
+<tr><th>Expression</th>
+<th>Return Type</th>
+<th>Postcondition</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="literal"><span class="pre">iter_swap(a,</span> <span class="pre">b)</span></tt></td>
+<td><tt class="literal"><span class="pre">void</span></tt></td>
+<td>the pointed to values are
+exchanged</td>
+</tr>
+</tbody>
+</table>
+<dl>
+<dt>[<em>Note:</em> An iterator that is a model of the <em>Readable</em> and <em>Writable Iterator</em> concepts</dt>
+<dd>is also a model of <em>Swappable Iterator</em>.  <em>--end note</em>]</dd>
+</dl>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="SwappableIterator.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/SwappableIterator.rst

@@ -0,0 +1,19 @@
+Swappable Iterator Concept
+..........................
+
+A class or built-in type ``X`` models the *Swappable Iterator* concept
+if, in addition to ``X`` being Copy Constructible, the following
+expressions are valid and respect the stated semantics.
+
++---------------------------------------------------------------------+
+|Swappable Iterator Requirements (in addition to Copy Constructible)  |
++-------------------------+-------------+-----------------------------+
+|Expression               |Return Type  |Postcondition                |
++=========================+=============+=============================+
+|``iter_swap(a, b)``      |``void``     |the pointed to values are    |
+|                         |             |exchanged                    |
++-------------------------+-------------+-----------------------------+
+
+[*Note:* An iterator that is a model of the *Readable* and *Writable Iterator* concepts
+  is also a model of *Swappable Iterator*.  *--end note*]
+

doc/WritableIterator.html

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Writable Iterator Concept</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Writable Iterator Concept</h1>
+<div class="document" id="writable-iterator-concept">
+<p>A class or built-in type <tt class="literal"><span class="pre">X</span></tt> models the <em>Writable Iterator</em> concept
+if, in addition to <tt class="literal"><span class="pre">X</span></tt> being Copy Constructible, the following
+expressions are valid and respect the stated semantics.  Writable
+Iterators have an associated <em>set of value types</em>.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="37%" />
+<col width="21%" />
+<col width="42%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th colspan="3">Writable Iterator Requirements (in addition to Copy Constructible)</th>
+</tr>
+<tr><th>Expression</th>
+<th>Return Type</th>
+<th>Precondition</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="literal"><span class="pre">*a</span> <span class="pre">=</span> <span class="pre">o</span></tt></td>
+<td>&nbsp;</td>
+<td>pre: The type of <tt class="literal"><span class="pre">o</span></tt>
+is in the set of
+value types of <tt class="literal"><span class="pre">X</span></tt></td>
+</tr>
+</tbody>
+</table>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="WritableIterator.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/WritableIterator.rst

@@ -0,0 +1,17 @@
+Writable Iterator Concept
+.........................
+
+A class or built-in type ``X`` models the *Writable Iterator* concept
+if, in addition to ``X`` being Copy Constructible, the following
+expressions are valid and respect the stated semantics.  Writable
+Iterators have an associated *set of value types*.
+
++---------------------------------------------------------------------+
+|Writable Iterator Requirements (in addition to Copy Constructible)   |
++-------------------------+--------------+----------------------------+
+|Expression               |Return Type   |Precondition                |
++=========================+==============+============================+
+|``*a = o``               |              | pre: The type of ``o``     |
+|                         |              | is in the set of           |
+|                         |              | value types of ``X``       |
++-------------------------+--------------+----------------------------+

doc/counting_iterator.html

@@ -3,12 +3,12 @@
 <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.3.0: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.8: http://docutils.sourceforge.net/" />
 <title>Counting Iterator</title>
 <meta name="author" content="David Abrahams, Jeremy Siek, Thomas Witt" />
 <meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab, University of Hanover Institute for Transport Railway Operation and Construction" />
-<meta name="date" content="2004-01-15" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003." />
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
@@ -27,24 +27,24 @@
 Lab</a>, University of Hanover <a class="last reference" href="http://www.ive.uni-hannover.de">Institute for Transport
 Railway Operation and Construction</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2004-01-15</td></tr>
+<td>2004-11-01</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
+<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.</td></tr>
 </tbody>
 </table>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
 <tr class="field"><th class="field-name">abstract:</th><td class="field-body"><p class="first">How would you fill up a vector with the numbers zero
-through one hundred using <tt class="literal"><span class="pre">std::copy()</span></tt>?  The only iterator
+through one hundred using <tt class="docutils literal"><span class="pre">std::copy()</span></tt>?  The only iterator
 operation missing from builtin integer types is an
-<tt class="literal"><span class="pre">operator*()</span></tt> that returns the current value of the integer.
+<tt class="docutils literal"><span class="pre">operator*()</span></tt> that returns the current value of the integer.
 The counting iterator adaptor adds this crucial piece of
 functionality to whatever type it wraps.  One can use the
 counting iterator adaptor not only with integer types, but with
 any incrementable type.</p>
-<p class="last"><tt class="literal"><span class="pre">counting_iterator</span></tt> adapts an object by adding an <tt class="literal"><span class="pre">operator*</span></tt> that
+<p class="last"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt> adapts an object by adding an <tt class="docutils literal"><span class="pre">operator*</span></tt> that
 returns the current value of the object. All other iterator operations
 are forwarded to the adapted object.</p>
 </td>
@@ -52,17 +52,17 @@ are forwarded to the adapted object.</p>
 </tbody>
 </table>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
+<p class="topic-title first"><a name="table-of-contents">Table of Contents</a></p>
 <ul class="simple">
-<li><a class="reference" href="#counting-iterator-synopsis" id="id2" name="id2"><tt class="literal"><span class="pre">counting_iterator</span></tt> synopsis</a></li>
-<li><a class="reference" href="#counting-iterator-requirements" id="id3" name="id3"><tt class="literal"><span class="pre">counting_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#counting-iterator-models" id="id4" name="id4"><tt class="literal"><span class="pre">counting_iterator</span></tt> models</a></li>
-<li><a class="reference" href="#counting-iterator-operations" id="id5" name="id5"><tt class="literal"><span class="pre">counting_iterator</span></tt> operations</a></li>
+<li><a class="reference" href="#counting-iterator-synopsis" id="id2" name="id2"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt> synopsis</a></li>
+<li><a class="reference" href="#counting-iterator-requirements" id="id3" name="id3"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt> requirements</a></li>
+<li><a class="reference" href="#counting-iterator-models" id="id4" name="id4"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt> models</a></li>
+<li><a class="reference" href="#counting-iterator-operations" id="id5" name="id5"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt> operations</a></li>
 <li><a class="reference" href="#example" id="id6" name="id6">Example</a></li>
 </ul>
 </div>
 <div class="section" id="counting-iterator-synopsis">
-<h1><a class="toc-backref" href="#id2" name="counting-iterator-synopsis"><tt class="literal"><span class="pre">counting_iterator</span></tt> synopsis</a></h1>
+<h1><a class="toc-backref" href="#id2" name="counting-iterator-synopsis"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt> synopsis</a></h1>
 <pre class="literal-block">
 template &lt;
     class Incrementable
@@ -89,10 +89,10 @@ private:
     Incrementable m_inc; // exposition
 };
 </pre>
-<p>If the <tt class="literal"><span class="pre">Difference</span></tt> argument is <tt class="literal"><span class="pre">use_default</span></tt> then
-<tt class="literal"><span class="pre">difference_type</span></tt> is an unspecified signed integral
-type. Otherwise <tt class="literal"><span class="pre">difference_type</span></tt> is <tt class="literal"><span class="pre">Difference</span></tt>.</p>
-<p><tt class="literal"><span class="pre">iterator_category</span></tt> is determined according to the following
+<p>If the <tt class="docutils literal"><span class="pre">Difference</span></tt> argument is <tt class="docutils literal"><span class="pre">use_default</span></tt> then
+<tt class="docutils literal"><span class="pre">difference_type</span></tt> is an unspecified signed integral
+type. Otherwise <tt class="docutils literal"><span class="pre">difference_type</span></tt> is <tt class="docutils literal"><span class="pre">Difference</span></tt>.</p>
+<p><tt class="docutils literal"><span class="pre">iterator_category</span></tt> is determined according to the following
 algorithm:</p>
 <pre class="literal-block">
 if (CategoryOrTraversal is not use_default)
@@ -105,31 +105,31 @@ else
          iterator_traversal&lt;Incrementable&gt;::type, 
          Incrementable, const Incrementable&amp;)
 </pre>
-<dl>
+<dl class="docutils">
 <dt>[<em>Note:</em> implementers are encouraged to provide an implementation of</dt>
-<dd><tt class="literal"><span class="pre">operator-</span></tt> and a <tt class="literal"><span class="pre">difference_type</span></tt> that avoids overflows in
-the cases where <tt class="literal"><span class="pre">std::numeric_limits&lt;Incrementable&gt;::is_specialized</span></tt>
+<dd><tt class="docutils literal"><span class="pre">operator-</span></tt> and a <tt class="docutils literal"><span class="pre">difference_type</span></tt> that avoids overflows in
+the cases where <tt class="docutils literal"><span class="pre">std::numeric_limits&lt;Incrementable&gt;::is_specialized</span></tt>
 is true.]</dd>
 </dl>
 </div>
 <div class="section" id="counting-iterator-requirements">
-<h1><a class="toc-backref" href="#id3" name="counting-iterator-requirements"><tt class="literal"><span class="pre">counting_iterator</span></tt> requirements</a></h1>
-<p>The <tt class="literal"><span class="pre">Incrementable</span></tt> argument shall be Copy Constructible and Assignable.</p>
-<p>If <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to <tt class="literal"><span class="pre">forward_iterator_tag</span></tt>
-or <tt class="literal"><span class="pre">forward_traversal_tag</span></tt>, the following must be well-formed:</p>
+<h1><a class="toc-backref" href="#id3" name="counting-iterator-requirements"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt> requirements</a></h1>
+<p>The <tt class="docutils literal"><span class="pre">Incrementable</span></tt> argument shall be Copy Constructible and Assignable.</p>
+<p>If <tt class="docutils literal"><span class="pre">iterator_category</span></tt> is convertible to <tt class="docutils literal"><span class="pre">forward_iterator_tag</span></tt>
+or <tt class="docutils literal"><span class="pre">forward_traversal_tag</span></tt>, the following must be well-formed:</p>
 <pre class="literal-block">
 Incrementable i, j;
 ++i;         // pre-increment
 i == j;      // operator equal
 </pre>
-<p>If <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to
-<tt class="literal"><span class="pre">bidirectional_iterator_tag</span></tt> or <tt class="literal"><span class="pre">bidirectional_traversal_tag</span></tt>,
+<p>If <tt class="docutils literal"><span class="pre">iterator_category</span></tt> is convertible to
+<tt class="docutils literal"><span class="pre">bidirectional_iterator_tag</span></tt> or <tt class="docutils literal"><span class="pre">bidirectional_traversal_tag</span></tt>,
 the following expression must also be well-formed:</p>
 <pre class="literal-block">
 --i
 </pre>
-<p>If <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to
-<tt class="literal"><span class="pre">random_access_iterator_tag</span></tt> or <tt class="literal"><span class="pre">random_access_traversal_tag</span></tt>,
+<p>If <tt class="docutils literal"><span class="pre">iterator_category</span></tt> is convertible to
+<tt class="docutils literal"><span class="pre">random_access_iterator_tag</span></tt> or <tt class="docutils literal"><span class="pre">random_access_traversal_tag</span></tt>,
 the following must must also be valid:</p>
 <pre class="literal-block">
 counting_iterator::difference_type n;
@@ -139,92 +139,92 @@ i &lt; j;
 </pre>
 </div>
 <div class="section" id="counting-iterator-models">
-<h1><a class="toc-backref" href="#id4" name="counting-iterator-models"><tt class="literal"><span class="pre">counting_iterator</span></tt> models</a></h1>
-<p>Specializations of <tt class="literal"><span class="pre">counting_iterator</span></tt> model Readable Lvalue
+<h1><a class="toc-backref" href="#id4" name="counting-iterator-models"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt> models</a></h1>
+<p>Specializations of <tt class="docutils literal"><span class="pre">counting_iterator</span></tt> model Readable Lvalue
 Iterator. In addition, they model the concepts corresponding to the
-iterator tags to which their <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible.
-Also, if <tt class="literal"><span class="pre">CategoryOrTraversal</span></tt> is not <tt class="literal"><span class="pre">use_default</span></tt> then
-<tt class="literal"><span class="pre">counting_iterator</span></tt> models the concept corresponding to the iterator
-tag <tt class="literal"><span class="pre">CategoryOrTraversal</span></tt>.  Otherwise, if
-<tt class="literal"><span class="pre">numeric_limits&lt;Incrementable&gt;::is_specialized</span></tt>, then
-<tt class="literal"><span class="pre">counting_iterator</span></tt> models Random Access Traversal Iterator.
-Otherwise, <tt class="literal"><span class="pre">counting_iterator</span></tt> models the same iterator traversal
-concepts modeled by <tt class="literal"><span class="pre">Incrementable</span></tt>.</p>
-<p><tt class="literal"><span class="pre">counting_iterator&lt;X,C1,D1&gt;</span></tt> is interoperable with
-<tt class="literal"><span class="pre">counting_iterator&lt;Y,C2,D2&gt;</span></tt> if and only if <tt class="literal"><span class="pre">X</span></tt> is
-interoperable with <tt class="literal"><span class="pre">Y</span></tt>.</p>
+iterator tags to which their <tt class="docutils literal"><span class="pre">iterator_category</span></tt> is convertible.
+Also, if <tt class="docutils literal"><span class="pre">CategoryOrTraversal</span></tt> is not <tt class="docutils literal"><span class="pre">use_default</span></tt> then
+<tt class="docutils literal"><span class="pre">counting_iterator</span></tt> models the concept corresponding to the iterator
+tag <tt class="docutils literal"><span class="pre">CategoryOrTraversal</span></tt>.  Otherwise, if
+<tt class="docutils literal"><span class="pre">numeric_limits&lt;Incrementable&gt;::is_specialized</span></tt>, then
+<tt class="docutils literal"><span class="pre">counting_iterator</span></tt> models Random Access Traversal Iterator.
+Otherwise, <tt class="docutils literal"><span class="pre">counting_iterator</span></tt> models the same iterator traversal
+concepts modeled by <tt class="docutils literal"><span class="pre">Incrementable</span></tt>.</p>
+<p><tt class="docutils literal"><span class="pre">counting_iterator&lt;X,C1,D1&gt;</span></tt> is interoperable with
+<tt class="docutils literal"><span class="pre">counting_iterator&lt;Y,C2,D2&gt;</span></tt> if and only if <tt class="docutils literal"><span class="pre">X</span></tt> is
+interoperable with <tt class="docutils literal"><span class="pre">Y</span></tt>.</p>
 </div>
 <div class="section" id="counting-iterator-operations">
-<h1><a class="toc-backref" href="#id5" name="counting-iterator-operations"><tt class="literal"><span class="pre">counting_iterator</span></tt> operations</a></h1>
+<h1><a class="toc-backref" href="#id5" name="counting-iterator-operations"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt> operations</a></h1>
 <p>In addition to the operations required by the concepts modeled by
-<tt class="literal"><span class="pre">counting_iterator</span></tt>, <tt class="literal"><span class="pre">counting_iterator</span></tt> provides the following
+<tt class="docutils literal"><span class="pre">counting_iterator</span></tt>, <tt class="docutils literal"><span class="pre">counting_iterator</span></tt> provides the following
 operations.</p>
-<p><tt class="literal"><span class="pre">counting_iterator();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">counting_iterator();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">Incrementable</span></tt> is Default Constructible.</td>
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="docutils literal"><span class="pre">Incrementable</span></tt> is Default Constructible.</td>
 </tr>
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Default construct the member <tt class="literal"><span class="pre">m_inc</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Default construct the member <tt class="docutils literal"><span class="pre">m_inc</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">counting_iterator(counting_iterator</span> <span class="pre">const&amp;</span> <span class="pre">rhs);</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">counting_iterator(counting_iterator</span> <span class="pre">const&amp;</span> <span class="pre">rhs);</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Construct member <tt class="literal"><span class="pre">m_inc</span></tt> from <tt class="literal"><span class="pre">rhs.m_inc</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Construct member <tt class="docutils literal"><span class="pre">m_inc</span></tt> from <tt class="docutils literal"><span class="pre">rhs.m_inc</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">explicit</span> <span class="pre">counting_iterator(Incrementable</span> <span class="pre">x);</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">explicit</span> <span class="pre">counting_iterator(Incrementable</span> <span class="pre">x);</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Construct member <tt class="literal"><span class="pre">m_inc</span></tt> from <tt class="literal"><span class="pre">x</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Construct member <tt class="docutils literal"><span class="pre">m_inc</span></tt> from <tt class="docutils literal"><span class="pre">x</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_inc</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">m_inc</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">counting_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">counting_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">++m_inc</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">++m_inc</span></tt></td>
 </tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*this</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">counting_iterator&amp;</span> <span class="pre">operator--();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">counting_iterator&amp;</span> <span class="pre">operator--();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">--m_inc</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">--m_inc</span></tt></td>
 </tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*this</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">Incrementable</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">Incrementable</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_inc</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">m_inc</span></tt></td>
 </tr>
 </tbody>
 </table>
@@ -232,12 +232,12 @@ operations.</p>
 template &lt;class Incrementable&gt;
 counting_iterator&lt;Incrementable&gt; make_counting_iterator(Incrementable x);
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">counting_iterator&lt;Incrementable&gt;</span></tt>
-with <tt class="literal"><span class="pre">current</span></tt> constructed from <tt class="literal"><span class="pre">x</span></tt>.</td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="docutils literal"><span class="pre">counting_iterator&lt;Incrementable&gt;</span></tt>
+with <tt class="docutils literal"><span class="pre">current</span></tt> constructed from <tt class="docutils literal"><span class="pre">x</span></tt>.</td>
 </tr>
 </tbody>
 </table>
@@ -245,8 +245,8 @@ with <tt class="literal"><span class="pre">current</span></tt> constructed from
 <div class="section" id="example">
 <h1><a class="toc-backref" href="#id6" name="example">Example</a></h1>
 <p>This example fills an array with numbers and a second array with
-pointers into the first array, using <tt class="literal"><span class="pre">counting_iterator</span></tt> for both
-tasks. Finally <tt class="literal"><span class="pre">indirect_iterator</span></tt> is used to print out the numbers
+pointers into the first array, using <tt class="docutils literal"><span class="pre">counting_iterator</span></tt> for both
+tasks. Finally <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> is used to print out the numbers
 into the first array via indirection through the second array.</p>
 <pre class="literal-block">
 int N = 7;
@@ -276,5 +276,10 @@ indirectly printing out the numbers from 0 to 7
 <p>The source code for this example can be found <a class="reference" href="../example/counting_iterator_example.cpp">here</a>.</p>
 </div>
 </div>
+<hr class="docutils footer" />
+<div class="footer">
+<a class="reference" href="counting_iterator.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
 </body>
 </html>

doc/counting_iterator.rst

@@ -8,7 +8,7 @@
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
 :date: $Date$
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu

doc/docutils.sty

@@ -0,0 +1,54 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%% docutils.sty: A style for docutils latex output %%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% o author: Alexander Schmolck (a.schmolck@gmx.net)
+%% o created: 2002-07-07 10:50:31+00:40
+%% o last modified: $Date: 2004/01/29 05:55:26 $
+%% o keywords: 
+%% o license: 
+%XXX titlesec
+%% XXX geometry
+\usepackage{graphicx}
+\usepackage{latexsym} % extra symbols
+\usepackage{url} % !!!: pay attention when using in other commands!!!
+\usepackage{verbatim} % normal verbatim has lenght-limit
+\usepackage{enumerate} % easy style choice with e.g: ``\begin{enumerate}[Ex i.]``
+\usepackage{hyperref} %href, htarget and hlink XXX: pdfauthor, pdfcreator etc.
+\usepackage{xr} %XXX do we need this?
+% need this to have ``fboxes`` in ``enviroments``, as well as ``verbatim``s
+\usepackage{fancybox} 
+\usepackage{mdwtab} % better tables and arrays (fixes spacing and adds
+                    % vertical align and multirows (m))
+\usepackage{ltxtable} % long and autoscaling tables (use X for autoscaled
+                      % columns)
+\newcommand{\transition}{\vspace{2em}\par\hrule{}\par\vspace{2em}}
+\newcommand{\classifier}[1]{(\textit{#1})}
+\newenvironment{topic}[1]%
+{\begin{Sbox}%
+    \begin{minipage}{.8\textwidth}%
+      \protect{\large{\textbf{#1}}}\par\vspace{.5em}}%
+{\end{minipage}\end{Sbox}\fbox{\TheSbox}\par\vspace{.5em}}
+%XXX shadow box for warnings?
+\newenvironment{admonition}[1]%
+{\begin{center}%
+  \begin{Sbox}%
+    \begin{minipage}{.9\textwidth}%
+      \protect{\textsc{#1}}\par\vspace{.2em}}%
+{\end{minipage}\end{Sbox}\fbox{\TheSbox}\par\vspace{.5em}\end{center}}
+
+\newenvironment{doctest}%
+{\VerbatimEnvironment
+ \begin{Verbatim}}%
+{\end{Verbatim}}
+% {%
+%     \begin{Sbox}%
+%     \begin{minipage}{.8\textwidth}%
+%       \protect{\large{\textsc{#1}}\par\vspace{.5em}}}%
+% {\end{minipage}\end{Sbox}\fbox{\TheSbox}\par\vspace{.5em}}
+%{\end{minipage}\end{Sbox}\fbox{\TheSbox}}
+
+
+%% just a piece of example code
+% \newcommand{\vitem}%
+% {\SaveVerb[{\item[\UseVerb{\MyTemp}]}]{\MyTemp}}

doc/facade-and-adaptor.rst

@@ -17,7 +17,7 @@
 
 .. _n1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
 
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu
@@ -196,10 +196,6 @@ which were easily implemented using ``iterator_adaptor``:
 * ``transform_iterator``, which applies a user-defined function object
   to the underlying values when dereferenced.
 
-* ``projection_iterator``, which is similar to ``transform_iterator``
-  except that when dereferenced it returns a reference instead of
-  a value.
-
 * ``filter_iterator``, which provides a view of an iterator range in
   which some elements of the underlying range are skipped.
 
@@ -420,12 +416,12 @@ Class template ``counting_iterator``
 Function output iterator
 ------------------------
 
-.. include:: function_output_iterator_abstract.rst
+.. include:: func_output_iter_abstract.rst
 
 Class template ``function_output_iterator``
 ...........................................
 
-.. include:: function_output_iterator_ref.rst
+.. include:: func_output_iter_ref.rst
 
 
 

doc/filter_iterator.html

@@ -3,16 +3,15 @@
 <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.3.1: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.6: http://docutils.sourceforge.net/" />
 <title>Filter Iterator</title>
 <meta name="author" content="David Abrahams, Jeremy Siek, Thomas Witt" />
 <meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab, University of Hanover Institute for Transport Railway Operation and Construction" />
-<meta name="date" content="2004-01-13" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003." />
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
-<div class="document" id="filter-iterator">
 <h1 class="title">Filter Iterator</h1>
 <table class="docinfo" frame="void" rules="none">
 <col class="docinfo-name" />
@@ -27,11 +26,12 @@
 Lab</a>, University of Hanover <a class="last reference" href="http://www.ive.uni-hannover.de">Institute for Transport
 Railway Operation and Construction</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2004-01-13</td></tr>
+<td>2004-11-01</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
+<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.</td></tr>
 </tbody>
 </table>
+<div class="document" id="filter-iterator">
 <table class="field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
@@ -50,17 +50,17 @@ sequence to be traversed.</td>
 </tbody>
 </table>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
+<p class="topic-title first"><a name="table-of-contents">Table of Contents</a></p>
 <ul class="simple">
-<li><a class="reference" href="#filter-iterator-synopsis" id="id2" name="id2"><tt class="literal"><span class="pre">filter_iterator</span></tt> synopsis</a></li>
-<li><a class="reference" href="#filter-iterator-requirements" id="id3" name="id3"><tt class="literal"><span class="pre">filter_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#filter-iterator-models" id="id4" name="id4"><tt class="literal"><span class="pre">filter_iterator</span></tt> models</a></li>
-<li><a class="reference" href="#filter-iterator-operations" id="id5" name="id5"><tt class="literal"><span class="pre">filter_iterator</span></tt> operations</a></li>
-<li><a class="reference" href="#example" id="id6" name="id6">Example</a></li>
+<li><a class="reference" href="#filter-iterator-synopsis" id="id3" name="id3"><tt class="literal"><span class="pre">filter_iterator</span></tt> synopsis</a></li>
+<li><a class="reference" href="#filter-filter-iterator" id="id4" name="id4"><tt class="literal"><span class="pre">filter_iterator</span></tt> requirements</a></li>
+<li><a class="reference" href="#filter-iterator-models" id="id5" name="id5"><tt class="literal"><span class="pre">filter_iterator</span></tt> models</a></li>
+<li><a class="reference" href="#id1" id="id6" name="id6"><tt class="literal"><span class="pre">filter_iterator</span></tt> operations</a></li>
+<li><a class="reference" href="#example" id="id7" name="id7">Example</a></li>
 </ul>
 </div>
 <div class="section" id="filter-iterator-synopsis">
-<h1><a class="toc-backref" href="#id2" name="filter-iterator-synopsis"><tt class="literal"><span class="pre">filter_iterator</span></tt> synopsis</a></h1>
+<h1><a class="toc-backref" href="#id3" name="filter-iterator-synopsis"><tt class="literal"><span class="pre">filter_iterator</span></tt> synopsis</a></h1>
 <!-- Copyright David Abrahams, Jeremy Siek, and Thomas Witt -->
 <!-- 2004. Use, modification and distribution is subject to the Boost -->
 <!-- Software License, Version 1.0. (See accompanying  file -->
@@ -95,13 +95,17 @@ private:
     Iterator m_end;   // exposition only
 };
 </pre>
-<p>If <tt class="literal"><span class="pre">Iterator</span></tt> models Readable Lvalue Iterator and Forward Traversal
+<p>If <tt class="literal"><span class="pre">Iterator</span></tt> models Readable Lvalue Iterator and Bidirectional Traversal
 Iterator then <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to
-<tt class="literal"><span class="pre">std::forward_iterator_tag</span></tt>. Otherwise <tt class="literal"><span class="pre">iterator_category</span></tt> is
+<tt class="literal"><span class="pre">std::bidirectional_iterator_tag</span></tt>. 
+Otherwise, if <tt class="literal"><span class="pre">Iterator</span></tt> models Readable Lvalue Iterator and Forward Traversal
+Iterator then <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to
+<tt class="literal"><span class="pre">std::forward_iterator_tag</span></tt>. 
+Otherwise <tt class="literal"><span class="pre">iterator_category</span></tt> is
 convertible to <tt class="literal"><span class="pre">std::input_iterator_tag</span></tt>.</p>
 </div>
-<div class="section" id="filter-iterator-requirements">
-<h1><a class="toc-backref" href="#id3" name="filter-iterator-requirements"><tt class="literal"><span class="pre">filter_iterator</span></tt> requirements</a></h1>
+<div class="section" id="filter-filter-iterator">
+<h1><a class="toc-backref" href="#id4" name="filter-filter-iterator"><tt class="literal"><span class="pre">filter_iterator</span></tt> requirements</a></h1>
 <p>The <tt class="literal"><span class="pre">Iterator</span></tt> argument shall meet the requirements of Readable
 Iterator and Single Pass Iterator or it shall meet the requirements of
 Input Iterator.</p>
@@ -112,14 +116,14 @@ the expression <tt class="literal"><span class="pre">p(x)</span></tt> must be va
 <tt class="literal"><span class="pre">p(x)</span></tt> must be convertible to <tt class="literal"><span class="pre">bool</span></tt>.</p>
 </div>
 <div class="section" id="filter-iterator-models">
-<h1><a class="toc-backref" href="#id4" name="filter-iterator-models"><tt class="literal"><span class="pre">filter_iterator</span></tt> models</a></h1>
+<h1><a class="toc-backref" href="#id5" name="filter-iterator-models"><tt class="literal"><span class="pre">filter_iterator</span></tt> models</a></h1>
 <p>The concepts that <tt class="literal"><span class="pre">filter_iterator</span></tt> models are dependent on which
 concepts the <tt class="literal"><span class="pre">Iterator</span></tt> argument models, as specified in the
 following tables.</p>
-<table border class="table">
+<table border="1" class="table">
 <colgroup>
-<col width="33%" />
-<col width="67%" />
+<col width="44%" />
+<col width="56%" />
 </colgroup>
 <thead valign="bottom">
 <tr><th>If <tt class="literal"><span class="pre">Iterator</span></tt> models</th>
@@ -133,9 +137,12 @@ following tables.</p>
 <tr><td>Forward Traversal Iterator</td>
 <td>Forward Traversal Iterator</td>
 </tr>
+<tr><td>Bidirectional Traversal Iterator</td>
+<td>Bidirectional Traversal Iterator</td>
+</tr>
 </tbody>
 </table>
-<table border class="table">
+<table border="1" class="table">
 <colgroup>
 <col width="41%" />
 <col width="59%" />
@@ -157,7 +164,7 @@ following tables.</p>
 </tr>
 </tbody>
 </table>
-<table border class="table">
+<table border="1" class="table">
 <colgroup>
 <col width="63%" />
 <col width="38%" />
@@ -177,13 +184,16 @@ following tables.</p>
 <tr><td>Writable Lvalue Iterator, Forward Traversal Iterator</td>
 <td>Mutable Forward Iterator</td>
 </tr>
+<tr><td>Writable Lvalue Iterator, Bidirectional Iterator</td>
+<td>Mutable Bidirectional Iterator</td>
+</tr>
 </tbody>
 </table>
 <p><tt class="literal"><span class="pre">filter_iterator&lt;P1,</span> <span class="pre">X&gt;</span></tt> is interoperable with <tt class="literal"><span class="pre">filter_iterator&lt;P2,</span> <span class="pre">Y&gt;</span></tt> 
 if and only if <tt class="literal"><span class="pre">X</span></tt> is interoperable with <tt class="literal"><span class="pre">Y</span></tt>.</p>
 </div>
-<div class="section" id="filter-iterator-operations">
-<h1><a class="toc-backref" href="#id5" name="filter-iterator-operations"><tt class="literal"><span class="pre">filter_iterator</span></tt> operations</a></h1>
+<div class="section" id="id1">
+<h1><a class="toc-backref" href="#id6" name="id1"><tt class="literal"><span class="pre">filter_iterator</span></tt> operations</a></h1>
 <p>In addition to those operations required by the concepts that
 <tt class="literal"><span class="pre">filter_iterator</span></tt> models, <tt class="literal"><span class="pre">filter_iterator</span></tt> provides the following
 operations.</p>
@@ -319,7 +329,7 @@ make_filter_iterator(Iterator x, Iterator end = Iterator());
 </table>
 </div>
 <div class="section" id="example">
-<h1><a class="toc-backref" href="#id6" name="example">Example</a></h1>
+<h1><a class="toc-backref" href="#id7" name="example">Example</a></h1>
 <p>This example uses <tt class="literal"><span class="pre">filter_iterator</span></tt> and then
 <tt class="literal"><span class="pre">make_filter_iterator</span></tt> to output only the positive integers from an
 array of integers. Then <tt class="literal"><span class="pre">make_filter_iterator</span></tt> is is used to output

doc/filter_iterator.rst

@@ -8,7 +8,7 @@
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
 :date: $Date$
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu

doc/filter_iterator_ref.html

@@ -0,0 +1,259 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title></title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<div class="document">
+<!-- Copyright David Abrahams, Jeremy Siek, and Thomas Witt -->
+<!-- 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)  -->
+<pre class="literal-block">
+template &lt;class Predicate, class Iterator&gt;
+class filter_iterator
+{
+ public:
+    typedef iterator_traits&lt;Iterator&gt;::value_type value_type;
+    typedef iterator_traits&lt;Iterator&gt;::reference reference;
+    typedef iterator_traits&lt;Iterator&gt;::pointer pointer;
+    typedef iterator_traits&lt;Iterator&gt;::difference_type difference_type;
+    typedef /* see below */ iterator_category;
+
+    filter_iterator();
+    filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());
+    filter_iterator(Iterator x, Iterator end = Iterator());
+    template&lt;class OtherIterator&gt;
+    filter_iterator(
+        filter_iterator&lt;Predicate, OtherIterator&gt; const&amp; t
+        , typename enable_if_convertible&lt;OtherIterator, Iterator&gt;::type* = 0 // exposition
+        );
+    Predicate predicate() const;
+    Iterator end() const;
+    Iterator const&amp; base() const;
+    reference operator*() const;
+    filter_iterator&amp; operator++();
+private:
+    Predicate m_pred; // exposition only
+    Iterator m_iter;  // exposition only
+    Iterator m_end;   // exposition only
+};
+</pre>
+<p>If <tt class="literal"><span class="pre">Iterator</span></tt> models Readable Lvalue Iterator and Bidirectional Traversal
+Iterator then <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to
+<tt class="literal"><span class="pre">std::bidirectional_iterator_tag</span></tt>. 
+Otherwise, if <tt class="literal"><span class="pre">Iterator</span></tt> models Readable Lvalue Iterator and Forward Traversal
+Iterator then <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to
+<tt class="literal"><span class="pre">std::forward_iterator_tag</span></tt>. 
+Otherwise <tt class="literal"><span class="pre">iterator_category</span></tt> is
+convertible to <tt class="literal"><span class="pre">std::input_iterator_tag</span></tt>.</p>
+<div class="section" id="filter-iterator">
+<h1><a name="filter-iterator"><tt class="literal"><span class="pre">filter_iterator</span></tt> requirements</a></h1>
+<p>The <tt class="literal"><span class="pre">Iterator</span></tt> argument shall meet the requirements of Readable
+Iterator and Single Pass Iterator or it shall meet the requirements of
+Input Iterator.</p>
+<p>The <tt class="literal"><span class="pre">Predicate</span></tt> argument must be Assignable, Copy Constructible, and
+the expression <tt class="literal"><span class="pre">p(x)</span></tt> must be valid where <tt class="literal"><span class="pre">p</span></tt> is an object of type
+<tt class="literal"><span class="pre">Predicate</span></tt>, <tt class="literal"><span class="pre">x</span></tt> is an object of type
+<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt>, and where the type of
+<tt class="literal"><span class="pre">p(x)</span></tt> must be convertible to <tt class="literal"><span class="pre">bool</span></tt>.</p>
+</div>
+<div class="section" id="filter-iterator-models">
+<h1><a name="filter-iterator-models"><tt class="literal"><span class="pre">filter_iterator</span></tt> models</a></h1>
+<p>The concepts that <tt class="literal"><span class="pre">filter_iterator</span></tt> models are dependent on which
+concepts the <tt class="literal"><span class="pre">Iterator</span></tt> argument models, as specified in the
+following tables.</p>
+<table border="1" class="table">
+<colgroup>
+<col width="44%" />
+<col width="56%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th>If <tt class="literal"><span class="pre">Iterator</span></tt> models</th>
+<th>then <tt class="literal"><span class="pre">filter_iterator</span></tt> models</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td>Single Pass Iterator</td>
+<td>Single Pass Iterator</td>
+</tr>
+<tr><td>Forward Traversal Iterator</td>
+<td>Forward Traversal Iterator</td>
+</tr>
+<tr><td>Bidirectional Traversal Iterator</td>
+<td>Bidirectional Traversal Iterator</td>
+</tr>
+</tbody>
+</table>
+<table border="1" class="table">
+<colgroup>
+<col width="41%" />
+<col width="59%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th>If <tt class="literal"><span class="pre">Iterator</span></tt> models</th>
+<th>then <tt class="literal"><span class="pre">filter_iterator</span></tt> models</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td>Readable Iterator</td>
+<td>Readable Iterator</td>
+</tr>
+<tr><td>Writable Iterator</td>
+<td>Writable Iterator</td>
+</tr>
+<tr><td>Lvalue Iterator</td>
+<td>Lvalue Iterator</td>
+</tr>
+</tbody>
+</table>
+<table border="1" class="table">
+<colgroup>
+<col width="63%" />
+<col width="38%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th>If <tt class="literal"><span class="pre">Iterator</span></tt> models</th>
+<th>then <tt class="literal"><span class="pre">filter_iterator</span></tt> models</th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td>Readable Iterator, Single Pass Iterator</td>
+<td>Input Iterator</td>
+</tr>
+<tr><td>Readable Lvalue Iterator, Forward Traversal Iterator</td>
+<td>Forward Iterator</td>
+</tr>
+<tr><td>Writable Lvalue Iterator, Forward Traversal Iterator</td>
+<td>Mutable Forward Iterator</td>
+</tr>
+<tr><td>Writable Lvalue Iterator, Bidirectional Iterator</td>
+<td>Mutable Bidirectional Iterator</td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">filter_iterator&lt;P1,</span> <span class="pre">X&gt;</span></tt> is interoperable with <tt class="literal"><span class="pre">filter_iterator&lt;P2,</span> <span class="pre">Y&gt;</span></tt> 
+if and only if <tt class="literal"><span class="pre">X</span></tt> is interoperable with <tt class="literal"><span class="pre">Y</span></tt>.</p>
+</div>
+<div class="section" id="id1">
+<h1><a name="id1"><tt class="literal"><span class="pre">filter_iterator</span></tt> operations</a></h1>
+<p>In addition to those operations required by the concepts that
+<tt class="literal"><span class="pre">filter_iterator</span></tt> models, <tt class="literal"><span class="pre">filter_iterator</span></tt> provides the following
+operations.</p>
+<p><tt class="literal"><span class="pre">filter_iterator();</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">Predicate</span></tt> and <tt class="literal"><span class="pre">Iterator</span></tt> must be Default Constructible.</td>
+</tr>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs a <tt class="literal"><span class="pre">filter_iterator</span></tt> whose``m_pred``,  <tt class="literal"><span class="pre">m_iter</span></tt>, and <tt class="literal"><span class="pre">m_end</span></tt> 
+members are a default constructed.</td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">filter_iterator(Predicate</span> <span class="pre">f,</span> <span class="pre">Iterator</span> <span class="pre">x,</span> <span class="pre">Iterator</span> <span class="pre">end</span> <span class="pre">=</span> <span class="pre">Iterator());</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs a <tt class="literal"><span class="pre">filter_iterator</span></tt> where <tt class="literal"><span class="pre">m_iter</span></tt> is either
+the first position in the range <tt class="literal"><span class="pre">[x,end)</span></tt> such that <tt class="literal"><span class="pre">f(*m_iter)</span> <span class="pre">==</span> <span class="pre">true</span></tt> 
+or else``m_iter == end``. The member <tt class="literal"><span class="pre">m_pred</span></tt> is constructed from
+<tt class="literal"><span class="pre">f</span></tt> and <tt class="literal"><span class="pre">m_end</span></tt> from <tt class="literal"><span class="pre">end</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">filter_iterator(Iterator</span> <span class="pre">x,</span> <span class="pre">Iterator</span> <span class="pre">end</span> <span class="pre">=</span> <span class="pre">Iterator());</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">Predicate</span></tt> must be Default Constructible and
+<tt class="literal"><span class="pre">Predicate</span></tt> is a class type (not a function pointer).</td>
+</tr>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs a <tt class="literal"><span class="pre">filter_iterator</span></tt> where <tt class="literal"><span class="pre">m_iter</span></tt> is either
+the first position in the range <tt class="literal"><span class="pre">[x,end)</span></tt> such that <tt class="literal"><span class="pre">m_pred(*m_iter)</span> <span class="pre">==</span> <span class="pre">true</span></tt> 
+or else``m_iter == end``. The member <tt class="literal"><span class="pre">m_pred</span></tt> is default constructed.</td>
+</tr>
+</tbody>
+</table>
+<pre class="literal-block">
+template &lt;class OtherIterator&gt;
+filter_iterator(
+    filter_iterator&lt;Predicate, OtherIterator&gt; const&amp; t
+    , typename enable_if_convertible&lt;OtherIterator, Iterator&gt;::type* = 0 // exposition
+    );``
+</pre>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">OtherIterator</span></tt> is implicitly convertible to <tt class="literal"><span class="pre">Iterator</span></tt>.</td>
+</tr>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs a filter iterator whose members are copied from <tt class="literal"><span class="pre">t</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">Predicate</span> <span class="pre">predicate()</span> <span class="pre">const;</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_pred</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">Iterator</span> <span class="pre">end()</span> <span class="pre">const;</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_end</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">Iterator</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*m_iter</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">filter_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Increments <tt class="literal"><span class="pre">m_iter</span></tt> and then continues to
+increment <tt class="literal"><span class="pre">m_iter</span></tt> until either <tt class="literal"><span class="pre">m_iter</span> <span class="pre">==</span> <span class="pre">m_end</span></tt>
+or <tt class="literal"><span class="pre">m_pred(*m_iter)</span> <span class="pre">==</span> <span class="pre">true</span></tt>.</td>
+</tr>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="filter_iterator_ref.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/filter_iterator_ref.rst

@@ -35,9 +35,13 @@
   };
 
 
-If ``Iterator`` models Readable Lvalue Iterator and Forward Traversal
+If ``Iterator`` models Readable Lvalue Iterator and Bidirectional Traversal
 Iterator then ``iterator_category`` is convertible to
-``std::forward_iterator_tag``. Otherwise ``iterator_category`` is
+``std::bidirectional_iterator_tag``. 
+Otherwise, if ``Iterator`` models Readable Lvalue Iterator and Forward Traversal
+Iterator then ``iterator_category`` is convertible to
+``std::forward_iterator_tag``. 
+Otherwise ``iterator_category`` is
 convertible to ``std::input_iterator_tag``.
 
 
@@ -62,13 +66,15 @@ The concepts that ``filter_iterator`` models are dependent on which
 concepts the ``Iterator`` argument models, as specified in the
 following tables.
 
-+-----------------------------+----------------------------------------------------------+
-| If ``Iterator`` models      | then ``filter_iterator`` models                          |
-+=============================+==========================================================+
-| Single Pass Iterator        | Single Pass Iterator                                     |
-+-----------------------------+----------------------------------------------------------+
-| Forward Traversal Iterator  | Forward Traversal Iterator                               |
-+-----------------------------+----------------------------------------------------------+
++---------------------------------+------------------------------------------+
+|If ``Iterator`` models           |then ``filter_iterator`` models           |
++=================================+==========================================+
+|Single Pass Iterator             |Single Pass Iterator                      |
++---------------------------------+------------------------------------------+
+|Forward Traversal Iterator       |Forward Traversal Iterator                |
++---------------------------------+------------------------------------------+
+|Bidirectional Traversal Iterator |Bidirectional Traversal Iterator          |
++---------------------------------+------------------------------------------+
 
 +--------------------------------+----------------------------------------------+
 | If ``Iterator`` models         | then ``filter_iterator`` models              |
@@ -81,13 +87,15 @@ following tables.
 +--------------------------------+----------------------------------------------+
 
 +-------------------------------------------------------+---------------------------------+
-| If ``Iterator`` models                                | then ``filter_iterator`` models |
+|If ``Iterator`` models                                 | then ``filter_iterator`` models |
 +=======================================================+=================================+
-| Readable Iterator, Single Pass Iterator               | Input Iterator                  |
+|Readable Iterator, Single Pass Iterator                | Input Iterator                  |
 +-------------------------------------------------------+---------------------------------+
-| Readable Lvalue Iterator, Forward Traversal Iterator  | Forward Iterator                |
+|Readable Lvalue Iterator, Forward Traversal Iterator   | Forward Iterator                |
 +-------------------------------------------------------+---------------------------------+
-| Writable Lvalue Iterator, Forward Traversal Iterator  | Mutable Forward Iterator        |
+|Writable Lvalue Iterator, Forward Traversal Iterator   | Mutable Forward Iterator        |
++-------------------------------------------------------+---------------------------------+
+|Writable Lvalue Iterator, Bidirectional Iterator       | Mutable Bidirectional Iterator  |
 +-------------------------------------------------------+---------------------------------+
 
 

doc/func_output_iter_ref.rst

@@ -9,7 +9,9 @@
     typedef void                     pointer;
     typedef void                     reference;
 
-    explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());
+    explicit function_output_iterator();
+
+    explicit function_output_iterator(const UnaryFunction& f);
 
     /* see below */ operator*();
     function_output_iterator& operator++();

doc/function_output_iterator.html

@@ -3,12 +3,12 @@
 <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.3.0: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.8: http://docutils.sourceforge.net/" />
 <title>Function Output Iterator</title>
 <meta name="author" content="David Abrahams, Jeremy Siek, Thomas Witt" />
 <meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab, University of Hanover Institute for Transport Railway Operation and Construction" />
-<meta name="date" content="2004-01-13" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003." />
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
@@ -27,12 +27,12 @@
 Lab</a>, University of Hanover <a class="last reference" href="http://www.ive.uni-hannover.de">Institute for Transport
 Railway Operation and Construction</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2004-01-13</td></tr>
+<td>2004-11-01</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
+<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.</td></tr>
 </tbody>
 </table>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
@@ -47,11 +47,11 @@ proxy object.</td>
 </tbody>
 </table>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
+<p class="topic-title first"><a name="table-of-contents">Table of Contents</a></p>
 <ul class="simple">
-<li><a class="reference" href="#function-output-iterator-requirements" id="id1" name="id1"><tt class="literal"><span class="pre">function_output_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#function-output-iterator-models" id="id2" name="id2"><tt class="literal"><span class="pre">function_output_iterator</span></tt> models</a></li>
-<li><a class="reference" href="#function-output-iterator-operations" id="id3" name="id3"><tt class="literal"><span class="pre">function_output_iterator</span></tt> operations</a></li>
+<li><a class="reference" href="#function-output-iterator-requirements" id="id1" name="id1"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt> requirements</a></li>
+<li><a class="reference" href="#function-output-iterator-models" id="id2" name="id2"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt> models</a></li>
+<li><a class="reference" href="#function-output-iterator-operations" id="id3" name="id3"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt> operations</a></li>
 <li><a class="reference" href="#example" id="id4" name="id4">Example</a></li>
 </ul>
 </div>
@@ -65,7 +65,9 @@ public:
   typedef void                     pointer;
   typedef void                     reference;
 
-  explicit function_output_iterator(const UnaryFunction&amp; f = UnaryFunction());
+  explicit function_output_iterator();
+
+  explicit function_output_iterator(const UnaryFunction&amp; f);
 
   /* see below */ operator*();
   function_output_iterator&amp; operator++();
@@ -75,51 +77,51 @@ private:
 };
 </pre>
 <div class="section" id="function-output-iterator-requirements">
-<h1><a class="toc-backref" href="#id1" name="function-output-iterator-requirements"><tt class="literal"><span class="pre">function_output_iterator</span></tt> requirements</a></h1>
-<p><tt class="literal"><span class="pre">UnaryFunction</span></tt> must be Assignable and Copy Constructible.</p>
+<h1><a class="toc-backref" href="#id1" name="function-output-iterator-requirements"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt> requirements</a></h1>
+<p><tt class="docutils literal"><span class="pre">UnaryFunction</span></tt> must be Assignable and Copy Constructible.</p>
 </div>
 <div class="section" id="function-output-iterator-models">
-<h1><a class="toc-backref" href="#id2" name="function-output-iterator-models"><tt class="literal"><span class="pre">function_output_iterator</span></tt> models</a></h1>
-<p><tt class="literal"><span class="pre">function_output_iterator</span></tt> is a model of the Writable and
+<h1><a class="toc-backref" href="#id2" name="function-output-iterator-models"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt> models</a></h1>
+<p><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt> is a model of the Writable and
 Incrementable Iterator concepts.</p>
 </div>
 <div class="section" id="function-output-iterator-operations">
-<h1><a class="toc-backref" href="#id3" name="function-output-iterator-operations"><tt class="literal"><span class="pre">function_output_iterator</span></tt> operations</a></h1>
-<p><tt class="literal"><span class="pre">explicit</span> <span class="pre">function_output_iterator(const</span> <span class="pre">UnaryFunction&amp;</span> <span class="pre">f</span> <span class="pre">=</span> <span class="pre">UnaryFunction());</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<h1><a class="toc-backref" href="#id3" name="function-output-iterator-operations"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt> operations</a></h1>
+<p><tt class="docutils literal"><span class="pre">explicit</span> <span class="pre">function_output_iterator(const</span> <span class="pre">UnaryFunction&amp;</span> <span class="pre">f</span> <span class="pre">=</span> <span class="pre">UnaryFunction());</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="literal"><span class="pre">function_output_iterator</span></tt> 
-with <tt class="literal"><span class="pre">m_f</span></tt> constructed from <tt class="literal"><span class="pre">f</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="docutils literal"><span class="pre">function_output_iterator</span></tt> 
+with <tt class="docutils literal"><span class="pre">m_f</span></tt> constructed from <tt class="docutils literal"><span class="pre">f</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">operator*();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">operator*();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An object <tt class="literal"><span class="pre">r</span></tt> of unspecified type such that <tt class="literal"><span class="pre">r</span> <span class="pre">=</span> <span class="pre">t</span></tt>
-is equivalent to <tt class="literal"><span class="pre">m_f(t)</span></tt> for all <tt class="literal"><span class="pre">t</span></tt>.</td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An object <tt class="docutils literal"><span class="pre">r</span></tt> of unspecified type such that <tt class="docutils literal"><span class="pre">r</span> <span class="pre">=</span> <span class="pre">t</span></tt>
+is equivalent to <tt class="docutils literal"><span class="pre">m_f(t)</span></tt> for all <tt class="docutils literal"><span class="pre">t</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">function_output_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">function_output_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*this</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">function_output_iterator&amp;</span> <span class="pre">operator++(int);</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">function_output_iterator&amp;</span> <span class="pre">operator++(int);</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*this</span></tt></td>
 </tr>
 </tbody>
 </table>
@@ -160,5 +162,10 @@ int main(int, char*[])
 </pre>
 </div>
 </div>
+<hr class="docutils footer" />
+<div class="footer">
+<a class="reference" href="function_output_iterator.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
 </body>
 </html>

doc/function_output_iterator.rst

@@ -8,7 +8,7 @@
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
 :date: $Date$
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu
@@ -16,9 +16,9 @@
 
 :abstract:
 
-  .. include:: function_output_iterator_abstract.rst
+  .. include:: func_output_iter_abstract.rst
 
 .. contents:: Table of Contents
 
-.. include:: function_output_iterator_ref.rst
+.. include:: func_output_iter_ref.rst
 .. include:: function_output_iterator_eg.rst

doc/generate.py

@@ -1,4 +1,7 @@
 #!/usr/bin/python
+# 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)
 
 #
 # Generate html, TeX, and PDF versions of all the source files
@@ -13,7 +16,7 @@ if 0:
     for s in sources:
         syscmd('boosthtml %s' % s)
 else:        
-    extensions = ('html', 'tex', 'pdf')
+    extensions = ('html', 'pdf')
 
     if len(sys.argv) > 1:
         extensions = sys.argv[1:]
@@ -23,7 +26,7 @@ else:
           for s in sources 
         ]
 
-    print 'make -k %s' % ' '.join(all)
-    syscmd('make -k %s' % ' '.join(all))
+    print 'make %s' % ' '.join(all)
+    syscmd('make %s' % ' '.join(all))
 
 

doc/index.html

@@ -3,15 +3,15 @@
 <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.3.1: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.8: http://docutils.sourceforge.net/" />
 <title>The Boost.Iterator Library Boost</title>
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
 <div class="document" id="the-boost-iterator-library-logo">
-<h1 class="title">The Boost.Iterator Library <a class="reference" href="../../../index.htm"><img alt="Boost" src="../../../c++boost.gif" /></a></h1>
-<hr />
-<table class="field-list" frame="void" rules="none">
+<h1 class="title">The Boost.Iterator Library <a class="reference" href="../../../index.htm"><img alt="Boost" src="../../../boost.png" /></a></h1>
+<hr class="docutils" />
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
@@ -24,11 +24,11 @@ Lab</a>, <a class="reference" href="http://www.styleadvisor.com">Zephyr Associat
 </tr>
 <tr class="field"><th class="field-name">date:</th><td class="field-body">$Date$</td>
 </tr>
-<tr class="field"><th class="field-name">copyright:</th><td class="field-body">Copyright David Abrahams, Jeremy Siek, Thomas Witt 2003. All rights reserved</td>
+<tr class="field"><th class="field-name">copyright:</th><td class="field-body">Copyright David Abrahams, Jeremy Siek, Thomas Witt 2003.</td>
 </tr>
 </tbody>
 </table>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
@@ -38,7 +38,7 @@ iterator requirements. The second is a framework of
 components for building iterators based on these
 extended concepts and includes several useful iterator
 adaptors. The extended iterator concepts have been
-carefully designed so that so that old-style iterators
+carefully designed so that old-style iterators
 can fit in the new concepts and so that new-style
 iterators will be compatible with old-style algorithms,
 though algorithms may need to be updated if they want to
@@ -51,141 +51,147 @@ older Boost Iterator Adaptor Library.</td>
 </tbody>
 </table>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents"><strong>Table of Contents</strong></a></p>
+<p class="topic-title first"><a name="table-of-contents"><strong>Table of Contents</strong></a></p>
 <ul class="simple">
-<li><a class="reference" href="#new-style-iterators" id="id6" name="id6">New-Style Iterators</a></li>
-<li><a class="reference" href="#iterator-facade-and-adaptor" id="id7" name="id7">Iterator Facade and Adaptor</a></li>
-<li><a class="reference" href="#specialized-adaptors" id="id8" name="id8">Specialized Adaptors</a></li>
-<li><a class="reference" href="#iterator-utilities" id="id9" name="id9">Iterator Utilities</a><ul>
-<li><a class="reference" href="#traits" id="id10" name="id10">Traits</a></li>
-<li><a class="reference" href="#testing-and-concept-checking" id="id11" name="id11">Testing and Concept Checking</a></li>
+<li><a class="reference" href="#new-style-iterators" id="id22" name="id22">New-Style Iterators</a></li>
+<li><a class="reference" href="#iterator-facade-and-adaptor" id="id23" name="id23">Iterator Facade and Adaptor</a></li>
+<li><a class="reference" href="#specialized-adaptors" id="id24" name="id24">Specialized Adaptors</a></li>
+<li><a class="reference" href="#iterator-utilities" id="id25" name="id25">Iterator Utilities</a><ul>
+<li><a class="reference" href="#traits" id="id26" name="id26">Traits</a></li>
+<li><a class="reference" href="#testing-and-concept-checking" id="id27" name="id27">Testing and Concept Checking</a></li>
 </ul>
 </li>
-<li><a class="reference" href="#upgrading-from-the-old-boost-iterator-adaptor-library" id="id12" name="id12">Upgrading from the old Boost Iterator Adaptor Library</a></li>
-<li><a class="reference" href="#history" id="id13" name="id13">History</a></li>
+<li><a class="reference" href="#upgrading-from-the-old-boost-iterator-adaptor-library" id="id28" name="id28">Upgrading from the old Boost Iterator Adaptor Library</a></li>
+<li><a class="reference" href="#history" id="id29" name="id29">History</a></li>
 </ul>
 </div>
-<hr />
+<hr class="docutils" />
 <div class="section" id="new-style-iterators">
-<h1><a class="toc-backref" href="#id6" name="new-style-iterators">New-Style Iterators</a></h1>
+<h1><a class="toc-backref" href="#id22" name="new-style-iterators">New-Style Iterators</a></h1>
 <p>The iterator categories defined in C++98 are extremely limiting
 because they bind together two orthogonal concepts: traversal and
 element access.  For example, because a random access iterator is
 required to return a reference (and not a proxy) when dereferenced,
 it is impossible to capture the capabilities of
-<tt class="literal"><span class="pre">vector&lt;bool&gt;::iterator</span></tt> using the C++98 categories.  This is the
-infamous &quot;<tt class="literal"><span class="pre">vector&lt;bool&gt;</span></tt> is not a container, and its iterators
+<tt class="docutils literal"><span class="pre">vector&lt;bool&gt;::iterator</span></tt> using the C++98 categories.  This is the
+infamous &quot;<tt class="docutils literal"><span class="pre">vector&lt;bool&gt;</span></tt> is not a container, and its iterators
 aren't random access iterators&quot;, debacle about which Herb Sutter
 wrote two papers for the standards comittee (<a class="reference" href="http://www.gotw.ca/publications/N1185.pdf">n1185</a> and <a class="reference" href="http://www.gotw.ca/publications/N1211.pdf">n1211</a>),
 and a <a class="reference" href="http://www.gotw.ca/gotw/050.htm">Guru of the Week</a>.  New-style iterators go well beyond
-patching up <tt class="literal"><span class="pre">vector&lt;bool&gt;</span></tt>, though: there are lots of other
+patching up <tt class="docutils literal"><span class="pre">vector&lt;bool&gt;</span></tt>, though: there are lots of other
 iterators already in use which can't be adequately represented by
 the existing concepts.  For details about the new iterator
 concepts, see our</p>
 <blockquote>
-<a class="reference" href="new-iter-concepts.html">Standard Proposal For New-Style Iterators</a></blockquote>
+<a class="reference" href="new-iter-concepts.html">Standard Proposal For New-Style Iterators</a> (<a class="reference" href="new-iter-concepts.pdf">PDF</a>)</blockquote>
 </div>
 <div class="section" id="iterator-facade-and-adaptor">
-<h1><a class="toc-backref" href="#id7" name="iterator-facade-and-adaptor">Iterator Facade and Adaptor</a></h1>
+<h1><a class="toc-backref" href="#id23" name="iterator-facade-and-adaptor">Iterator Facade and Adaptor</a></h1>
 <p>Writing standard-conforming iterators is tricky, but the need comes
 up often.  In order to ease the implementation of new iterators,
-the Boost.Iterator library provides the <tt class="literal"><span class="pre">iterator_facade</span></tt> class template,
+the Boost.Iterator library provides the <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> class template,
 which implements many useful defaults and compile-time checks
 designed to help the iterator author ensure that his iterator is
 correct.</p>
 <p>It is also common to define a new iterator that is similar to some
 underlying iterator or iterator-like type, but that modifies some
 aspect of the underlying type's behavior.  For that purpose, the
-library supplies the <tt class="literal"><span class="pre">iterator_adaptor</span></tt> class template, which is specially
+library supplies the <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> class template, which is specially
 designed to take advantage of as much of the underlying type's
 behavior as possible.</p>
 <p>The documentation for these two classes can be found at the following
 web pages:</p>
 <ul class="simple">
-<li><a class="reference" href="iterator_facade.html"><tt class="literal"><span class="pre">iterator_facade</span></tt></a></li>
-<li><a class="reference" href="iterator_adaptor.html"><tt class="literal"><span class="pre">iterator_adaptor</span></tt></a></li>
+<li><a class="reference" href="iterator_facade.html"><tt class="docutils literal"><span class="pre">iterator_facade</span></tt></a> (<a class="reference" href="iterator_facade.pdf">PDF</a>)</li>
+<li><a class="reference" href="iterator_adaptor.html"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt></a> (<a class="reference" href="iterator_adaptor.pdf">PDF</a>)</li>
 </ul>
-<p>Both <tt class="literal"><span class="pre">iterator_facade</span></tt> and <tt class="literal"><span class="pre">iterator_adaptor</span></tt> as well as many of the <a class="reference" href="#specialized-adaptors">specialized
+<p>Both <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> and <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> as well as many of the <a class="reference" href="#specialized-adaptors">specialized
 adaptors</a> mentioned below have been proposed for standardization,
 and accepted into the first C++ technical report; see our</p>
 <blockquote>
-<a class="reference" href="facade-and-adaptor.html">Standard Proposal For Iterator Facade and Adaptor</a></blockquote>
+<a class="reference" href="facade-and-adaptor.html">Standard Proposal For Iterator Facade and Adaptor</a> (<a class="reference" href="facade-and-adaptor.pdf">PDF</a>)</blockquote>
 <p>for more details.</p>
 </div>
 <div class="section" id="specialized-adaptors">
-<h1><a class="toc-backref" href="#id8" name="specialized-adaptors">Specialized Adaptors</a></h1>
+<h1><a class="toc-backref" href="#id24" name="specialized-adaptors">Specialized Adaptors</a></h1>
 <p>The iterator library supplies a useful suite of standard-conforming
 iterator templates based on the Boost <a class="reference" href="#iterator-facade-and-adaptor">iterator facade and adaptor</a>.</p>
 <ul class="simple">
-<li><a class="reference" href="counting_iterator.html"><tt class="literal"><span class="pre">counting_iterator</span></tt></a>: an iterator over a sequence of consecutive values.
+<li><a class="reference" href="counting_iterator.html"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt></a> (<a class="reference" href="counting_iterator.pdf">PDF</a>): an iterator over a sequence of consecutive values.
 Implements a &quot;lazy sequence&quot;</li>
-<li><a class="reference" href="filter_iterator.html"><tt class="literal"><span class="pre">filter_iterator</span></tt></a>: an iterator over the subset of elements of some
+<li><a class="reference" href="filter_iterator.html"><tt class="docutils literal"><span class="pre">filter_iterator</span></tt></a> (<a class="reference" href="filter_iterator.pdf">PDF</a>): an iterator over the subset of elements of some
 sequence which satisfy a given predicate</li>
-<li><a class="reference" href="indirect_iterator.html"><tt class="literal"><span class="pre">indirect_iterator</span></tt></a>: an iterator over the objects <em>pointed-to</em> by the
+<li><a class="reference" href="function_output_iterator.html"><tt class="docutils literal"><span class="pre">function_output_iterator</span></tt></a> (<a class="reference" href="function_output_iterator.pdf">PDF</a>): an output iterator wrapping a unary function
+object; each time an element is written into the dereferenced
+iterator, it is passed as a parameter to the function object.</li>
+<li><a class="reference" href="indirect_iterator.html"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt></a> (<a class="reference" href="indirect_iterator.pdf">PDF</a>): an iterator over the objects <em>pointed-to</em> by the
 elements of some sequence.</li>
-<li><a class="reference" href="permutation_iterator.html"><tt class="literal"><span class="pre">permutation_iterator</span></tt></a>: an iterator over the elements of some random-access
+<li><a class="reference" href="permutation_iterator.html"><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt></a> (<a class="reference" href="permutation_iterator.pdf">PDF</a>): an iterator over the elements of some random-access
 sequence, rearranged according to some sequence of integer indices.</li>
-<li><a class="reference" href="reverse_iterator.html"><tt class="literal"><span class="pre">reverse_iterator</span></tt></a>: an iterator which traverses the elements of some
+<li><a class="reference" href="reverse_iterator.html"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt></a> (<a class="reference" href="reverse_iterator.pdf">PDF</a>): an iterator which traverses the elements of some
 bidirectional sequence in reverse.  Corrects many of the
-shortcomings of C++98's <tt class="literal"><span class="pre">std::reverse_iterator</span></tt>.</li>
-<li><a class="reference" href="transform_iterator.html"><tt class="literal"><span class="pre">transform_iterator</span></tt></a>: an iterator over elements which are the result of
+shortcomings of C++98's <tt class="docutils literal"><span class="pre">std::reverse_iterator</span></tt>.</li>
+<li><a class="reference" href="../../utility/shared_container_iterator.html"><tt class="docutils literal"><span class="pre">shared_container_iterator</span></tt></a>: an iterator over elements of a container whose
+lifetime is maintained by a <a class="reference" href="../../smart_ptr/shared_ptr.htm"><tt class="docutils literal"><span class="pre">shared_ptr</span></tt></a> stored in the iterator.</li>
+<li><a class="reference" href="transform_iterator.html"><tt class="docutils literal"><span class="pre">transform_iterator</span></tt></a> (<a class="reference" href="transform_iterator.pdf">PDF</a>): an iterator over elements which are the result of
 applying some functional transformation to the elements of an
 underlying sequence.  This component also replaces the old
-<tt class="literal"><span class="pre">projection_iterator_adaptor</span></tt>.</li>
-<li><a class="reference" href="zip_iterator.html"><tt class="literal"><span class="pre">zip_iterator</span></tt></a>: an iterator over tuples of the elements at corresponding
+<tt class="docutils literal"><span class="pre">projection_iterator_adaptor</span></tt>.</li>
+<li><a class="reference" href="zip_iterator.html"><tt class="docutils literal"><span class="pre">zip_iterator</span></tt></a> (<a class="reference" href="zip_iterator.pdf">PDF</a>): an iterator over tuples of the elements at corresponding
 positions of heterogeneous underlying iterators.</li>
 </ul>
 </div>
 <div class="section" id="iterator-utilities">
-<h1><a class="toc-backref" href="#id9" name="iterator-utilities">Iterator Utilities</a></h1>
+<h1><a class="toc-backref" href="#id25" name="iterator-utilities">Iterator Utilities</a></h1>
 <div class="section" id="traits">
-<h2><a class="toc-backref" href="#id10" name="traits">Traits</a></h2>
+<h2><a class="toc-backref" href="#id26" name="traits">Traits</a></h2>
 <ul class="simple">
-<li><a class="reference" href="pointee.html"><tt class="literal"><span class="pre">pointee.hpp</span></tt></a>: Provides the capability to deduce the referent types
+<li><a class="reference" href="pointee.html"><tt class="docutils literal"><span class="pre">pointee.hpp</span></tt></a> (<a class="reference" href="pointee.pdf">PDF</a>): Provides the capability to deduce the referent types
 of pointers, smart pointers and iterators in generic code.  Used
-in <tt class="literal"><span class="pre">indirect_iterator</span></tt>.</li>
-<li><a class="reference" href="iterator_traits.html"><tt class="literal"><span class="pre">iterator_traits.hpp</span></tt></a>: Provides <a class="reference" href="../../mpl/doc/index.html">MPL</a>-compatible metafunctions which
+in <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt>.</li>
+<li><a class="reference" href="iterator_traits.html"><tt class="docutils literal"><span class="pre">iterator_traits.hpp</span></tt></a> (<a class="reference" href="iterator_traits.pdf">PDF</a>): Provides <a class="reference" href="../../mpl/doc/index.html">MPL</a>-compatible metafunctions which
 retrieve an iterator's traits.  Also corrects for the deficiencies
-of broken implementations of <tt class="literal"><span class="pre">std::iterator_traits</span></tt>.</li>
-<li><a class="reference" href="interoperable.html"><tt class="literal"><span class="pre">interoperable.hpp</span></tt></a>: Provides an <a class="reference" href="../../mpl/doc/index.html">MPL</a>-compatible metafunction for
-testing iterator interoperability</li>
+of broken implementations of <tt class="docutils literal"><span class="pre">std::iterator_traits</span></tt>.</li>
 </ul>
+<!-- * |interoperable|_ (PDF__): Provides an MPL_\ -compatible metafunction for
+testing iterator interoperability -->
+<!-- comment! __ interoperable.pdf -->
 </div>
 <div class="section" id="testing-and-concept-checking">
-<h2><a class="toc-backref" href="#id11" name="testing-and-concept-checking">Testing and Concept Checking</a></h2>
+<h2><a class="toc-backref" href="#id27" name="testing-and-concept-checking">Testing and Concept Checking</a></h2>
 <ul class="simple">
-<li><a class="reference" href="iterator_concepts.html"><tt class="literal"><span class="pre">iterator_concepts.hpp</span></tt></a>: Concept checking classes for the new iterator concepts.</li>
-<li><a class="reference" href="iterator_archetypes.html"><tt class="literal"><span class="pre">iterator_archetypes.hpp</span></tt></a>: Concept archetype classes for the new iterators concepts.</li>
+<li><a class="reference" href="iterator_concepts.html"><tt class="docutils literal"><span class="pre">iterator_concepts.hpp</span></tt></a> (<a class="reference" href="iterator_concepts.pdf">PDF</a>): Concept checking classes for the new iterator concepts.</li>
+<li><a class="reference" href="iterator_archetypes.html"><tt class="docutils literal"><span class="pre">iterator_archetypes.hpp</span></tt></a> (<a class="reference" href="iterator_archetypes.pdf">PDF</a>): Concept archetype classes for the new iterators concepts.</li>
 </ul>
 </div>
 </div>
 <div class="section" id="upgrading-from-the-old-boost-iterator-adaptor-library">
-<h1><a class="toc-backref" href="#id12" name="upgrading-from-the-old-boost-iterator-adaptor-library">Upgrading from the old Boost Iterator Adaptor Library</a></h1>
+<h1><a class="toc-backref" href="#id28" name="upgrading-from-the-old-boost-iterator-adaptor-library">Upgrading from the old Boost Iterator Adaptor Library</a></h1>
 <a class="target" id="upgrading" name="upgrading"></a><p>If you have been using the old Boost Iterator Adaptor library to
-implement iterators, you probably wrote a <tt class="literal"><span class="pre">Policies</span></tt> class which
+implement iterators, you probably wrote a <tt class="docutils literal"><span class="pre">Policies</span></tt> class which
 captures the core operations of your iterator.  In the new library
 design, you'll move those same core operations into the body of the
 iterator class itself.  If you were writing a family of iterators,
 you probably wrote a <a class="reference" href="../../../more/generic_programming.html#type_generator">type generator</a> to build the
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt> specialization you needed; in the new library
+<tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> specialization you needed; in the new library
 design you don't need a type generator (though may want to keep it
 around as a compatibility aid for older code) because, due to the
-use of the Curiously Recurring Template Pattern (CRTP) <a class="citation-reference" href="#cop95" id="id5" name="id5">[Cop95]</a>,
+use of the Curiously Recurring Template Pattern (CRTP) <a class="citation-reference" href="#cop95" id="id21" name="id21">[Cop95]</a>,
 you can now define the iterator class yourself and acquire
-functionality through inheritance from <tt class="literal"><span class="pre">iterator_facade</span></tt> or
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt>.  As a result, you also get much finer control
+functionality through inheritance from <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> or
+<tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>.  As a result, you also get much finer control
 over how your iterator works: you can add additional constructors,
 or even override the iterator functionality provided by the
 library.</p>
-<p>If you're looking for the old <tt class="literal"><span class="pre">projection_iterator</span></tt> component,
-its functionality has been merged into <tt class="literal"><span class="pre">transform_iterator</span></tt>: as
-long as the function object's <tt class="literal"><span class="pre">result_type</span></tt> (or the <tt class="literal"><span class="pre">Reference</span></tt>
+<p>If you're looking for the old <tt class="docutils literal"><span class="pre">projection_iterator</span></tt> component,
+its functionality has been merged into <tt class="docutils literal"><span class="pre">transform_iterator</span></tt>: as
+long as the function object's <tt class="docutils literal"><span class="pre">result_type</span></tt> (or the <tt class="docutils literal"><span class="pre">Reference</span></tt>
 template argument, if explicitly specified) is a true reference
-type, <tt class="literal"><span class="pre">transform_iterator</span></tt> will behave like
-<tt class="literal"><span class="pre">projection_iterator</span></tt> used to.</p>
+type, <tt class="docutils literal"><span class="pre">transform_iterator</span></tt> will behave like
+<tt class="docutils literal"><span class="pre">projection_iterator</span></tt> used to.</p>
 </div>
 <div class="section" id="history">
-<h1><a class="toc-backref" href="#id13" name="history">History</a></h1>
+<h1><a class="toc-backref" href="#id29" name="history">History</a></h1>
 <p>In 2000 Dave Abrahams was writing an iterator for a container of
 pointers, which would access the pointed-to elements when
 dereferenced.  Naturally, being a library writer, he decided to
@@ -206,15 +212,14 @@ policies into the iterator class itself.  Thomas Witt expressed
 interest and became the voice of strict compile-time checking for
 the project, adding uses of the SFINAE technique to eliminate false
 converting constructors and operators from the overload set.  He
-also recognized the need for a separate <tt class="literal"><span class="pre">iterator_facade</span></tt>, and
-factored it out of <tt class="literal"><span class="pre">iterator_adaptor</span></tt>.  Finally, after a
+also recognized the need for a separate <tt class="docutils literal"><span class="pre">iterator_facade</span></tt>, and
+factored it out of <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>.  Finally, after a
 near-complete rewrite of the prototype, they came up with the
 library you see today.</p>
-<table class="citation" frame="void" id="cop95" rules="none">
+<table class="docutils citation" frame="void" id="cop95" rules="none">
 <colgroup><col class="label" /><col /></colgroup>
-<col />
 <tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id5" name="cop95">[Cop95]</a></td><td>[Coplien, 1995] Coplien, J., Curiously Recurring Template
+<tr><td class="label"><a class="fn-backref" href="#id21" name="cop95">[Cop95]</a></td><td>[Coplien, 1995] Coplien, J., Curiously Recurring Template
 Patterns, C++ Report, February 1995, pp. 24-27.</td></tr>
 </tbody>
 </table>
@@ -227,7 +232,7 @@ LocalWords:  incrementable xxx min prev inplace png oldeqnew AccessTag struct
 LocalWords:  TraversalTag typename lvalues DWA Hmm JGS -->
 </div>
 </div>
-<hr class="footer" />
+<hr class="docutils footer" />
 <div class="footer">
 <a class="reference" href="index.rst">View document source</a>.
 Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.

doc/index.rst

@@ -2,7 +2,7 @@
  The Boost.Iterator Library |(logo)|__
 +++++++++++++++++++++++++++++++++++++++++++++++++
 
-.. |(logo)| image:: ../../../c++boost.gif
+.. |(logo)| image:: ../../../boost.png
    :alt: Boost
 
 __ ../../../index.htm
@@ -17,7 +17,7 @@ __ ../../../index.htm
                 Lab`_, `Zephyr Associates, Inc.`_
 :date:          $Date$
 
-:copyright:     Copyright David Abrahams, Jeremy Siek, Thomas Witt 2003. All rights reserved
+:copyright:     Copyright David Abrahams, Jeremy Siek, Thomas Witt 2003.
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu
@@ -29,7 +29,7 @@ __ ../../../index.htm
            components for building iterators based on these
            extended concepts and includes several useful iterator
            adaptors. The extended iterator concepts have been
-           carefully designed so that so that old-style iterators
+           carefully designed so that old-style iterators
            can fit in the new concepts and so that new-style
            iterators will be compatible with old-style algorithms,
            though algorithms may need to be updated if they want to
@@ -71,9 +71,10 @@ concepts, see our
 __ http://www.gotw.ca/gotw/050.htm
 
 
-   `Standard Proposal For New-Style Iterators`__
+   `Standard Proposal For New-Style Iterators`__ (PDF__)
 
 __ new-iter-concepts.html
+__ new-iter-concepts.pdf
 
 =============================
  Iterator Facade and Adaptor
@@ -96,25 +97,29 @@ behavior as possible.
 The documentation for these two classes can be found at the following
 web pages:
 
-* |facade|_
+* |facade|_ (PDF__)
 
-* |adaptor|_
+* |adaptor|_ (PDF__)
 
 
 .. |facade| replace:: ``iterator_facade``
 .. _facade: iterator_facade.html
+__ iterator_facade.pdf
+
 .. |adaptor| replace:: ``iterator_adaptor``
 .. _adaptor: iterator_adaptor.html
+__ iterator_adaptor.pdf
 
 Both |facade| and |adaptor| as well as many of the `specialized
 adaptors`_ mentioned below have been proposed for standardization,
 and accepted into the first C++ technical report; see our
 
-   `Standard Proposal For Iterator Facade and Adaptor`__
+   `Standard Proposal For Iterator Facade and Adaptor`__ (PDF__)
 
 for more details.
 
 __ facade-and-adaptor.html
+__ facade-and-adaptor.pdf
 
 ======================
  Specialized Adaptors
@@ -123,50 +128,74 @@ __ facade-and-adaptor.html
 The iterator library supplies a useful suite of standard-conforming
 iterator templates based on the Boost `iterator facade and adaptor`_.
 
-* |counting|_: an iterator over a sequence of consecutive values.
+* |counting|_ (PDF__): an iterator over a sequence of consecutive values.
   Implements a "lazy sequence"
 
-* |filter|_: an iterator over the subset of elements of some
+* |filter|_ (PDF__): an iterator over the subset of elements of some
   sequence which satisfy a given predicate
 
-* |indirect|_: an iterator over the objects *pointed-to* by the
+* |function|_ (PDF__): an output iterator wrapping a unary function
+  object; each time an element is written into the dereferenced
+  iterator, it is passed as a parameter to the function object.
+
+* |indirect|_ (PDF__): an iterator over the objects *pointed-to* by the
   elements of some sequence.
 
-* |permutation|_: an iterator over the elements of some random-access
+* |permutation|_ (PDF__): an iterator over the elements of some random-access
   sequence, rearranged according to some sequence of integer indices.
 
-* |reverse|_: an iterator which traverses the elements of some
+* |reverse|_ (PDF__): an iterator which traverses the elements of some
   bidirectional sequence in reverse.  Corrects many of the
   shortcomings of C++98's ``std::reverse_iterator``.
 
-* |transform|_: an iterator over elements which are the result of
+* |shared|_: an iterator over elements of a container whose
+  lifetime is maintained by a |shared_ptr|_ stored in the iterator.
+
+* |transform|_ (PDF__): an iterator over elements which are the result of
   applying some functional transformation to the elements of an
   underlying sequence.  This component also replaces the old
   ``projection_iterator_adaptor``.
 
-* |zip|_: an iterator over tuples of the elements at corresponding
+* |zip|_ (PDF__): an iterator over tuples of the elements at corresponding
   positions of heterogeneous underlying iterators.
 
 .. |counting| replace:: ``counting_iterator``
 .. _counting: counting_iterator.html
+__ counting_iterator.pdf
 
 .. |filter| replace:: ``filter_iterator``
 .. _filter: filter_iterator.html
+__ filter_iterator.pdf
+
+.. |function| replace:: ``function_output_iterator``
+.. _function: function_output_iterator.html
+__ function_output_iterator.pdf
 
 .. |indirect| replace:: ``indirect_iterator``
 .. _indirect: indirect_iterator.html
+__ indirect_iterator.pdf
 
 .. |permutation| replace:: ``permutation_iterator``
 .. _permutation: permutation_iterator.html
+__ permutation_iterator.pdf
 
 .. |reverse| replace:: ``reverse_iterator``
 .. _reverse: reverse_iterator.html
+__ reverse_iterator.pdf
+
+.. |shared| replace:: ``shared_container_iterator``
+.. _shared: ../../utility/shared_container_iterator.html
 
 .. |transform| replace:: ``transform_iterator``
 .. _transform: transform_iterator.html
+__ transform_iterator.pdf
 
 .. |zip| replace:: ``zip_iterator``
 .. _zip: zip_iterator.html
+__ zip_iterator.pdf
+
+.. |shared_ptr| replace:: ``shared_ptr``
+.. _shared_ptr: ../../smart_ptr/shared_ptr.htm
 
 ====================
  Iterator Utilities
@@ -175,41 +204,45 @@ iterator templates based on the Boost `iterator facade and adaptor`_.
 Traits
 ------
 
-* |pointee|_: Provides the capability to deduce the referent types
+* |pointee|_ (PDF__): Provides the capability to deduce the referent types
   of pointers, smart pointers and iterators in generic code.  Used
   in |indirect|.
 
-* |iterator_traits|_: Provides MPL_\ -compatible metafunctions which
+* |iterator_traits|_ (PDF__): Provides MPL_\ -compatible metafunctions which
   retrieve an iterator's traits.  Also corrects for the deficiencies
   of broken implementations of ``std::iterator_traits``.
 
-* |interoperable|_: Provides an MPL_\ -compatible metafunction for
-  testing iterator interoperability
+.. * |interoperable|_ (PDF__): Provides an MPL_\ -compatible metafunction for
+     testing iterator interoperability
 
 .. |pointee| replace:: ``pointee.hpp``
 .. _pointee: pointee.html
+__ pointee.pdf
 
 .. |iterator_traits| replace:: ``iterator_traits.hpp``
 .. _iterator_traits: iterator_traits.html
+__ iterator_traits.pdf
 
 .. |interoperable| replace:: ``interoperable.hpp``
 .. _interoperable: interoperable.html
+.. comment! __ interoperable.pdf
 
 .. _MPL: ../../mpl/doc/index.html
 
 Testing and Concept Checking
 ----------------------------
 
-* |iterator_concepts|_: Concept checking classes for the new iterator concepts.
+* |iterator_concepts|_ (PDF__): Concept checking classes for the new iterator concepts.
 
-* |iterator_archetypes|_: Concept archetype classes for the new iterators concepts.
+* |iterator_archetypes|_ (PDF__): Concept archetype classes for the new iterators concepts.
 
 .. |iterator_concepts| replace:: ``iterator_concepts.hpp``
 .. _iterator_concepts: iterator_concepts.html
+__ iterator_concepts.pdf
 
 .. |iterator_archetypes| replace:: ``iterator_archetypes.hpp``
 .. _iterator_archetypes: iterator_archetypes.html
-
+__ iterator_archetypes.pdf
 
 =======================================================
  Upgrading from the old Boost Iterator Adaptor Library

doc/indirect_iterator.html

@@ -3,12 +3,12 @@
 <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.3.1: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.8: http://docutils.sourceforge.net/" />
 <title>Indirect Iterator</title>
 <meta name="author" content="David Abrahams, Jeremy Siek, Thomas Witt" />
 <meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab, University of Hanover Institute for Transport Railway Operation and Construction" />
-<meta name="date" content="2004-01-15" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003." />
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
@@ -27,38 +27,38 @@
 Lab</a>, University of Hanover <a class="last reference" href="http://www.ive.uni-hannover.de">Institute for Transport
 Railway Operation and Construction</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2004-01-15</td></tr>
+<td>2004-11-01</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
+<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.</td></tr>
 </tbody>
 </table>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">abstract:</th><td class="field-body"><tt class="literal"><span class="pre">indirect_iterator</span></tt> adapts an iterator by applying an
-<em>extra</em> dereference inside of <tt class="literal"><span class="pre">operator*()</span></tt>. For example, this
+<tr class="field"><th class="field-name">abstract:</th><td class="field-body"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> adapts an iterator by applying an
+<em>extra</em> dereference inside of <tt class="docutils literal"><span class="pre">operator*()</span></tt>. For example, this
 iterator adaptor makes it possible to view a container of pointers
-(e.g. <tt class="literal"><span class="pre">list&lt;foo*&gt;</span></tt>) as if it were a container of the pointed-to type
-(e.g. <tt class="literal"><span class="pre">list&lt;foo&gt;</span></tt>).  <tt class="literal"><span class="pre">indirect_iterator</span></tt> depends on two
-auxiliary traits, <tt class="literal"><span class="pre">pointee</span></tt> and <tt class="literal"><span class="pre">indirect_reference</span></tt>, to
-provide support for underlying iterators whose <tt class="literal"><span class="pre">value_type</span></tt> is
+(e.g. <tt class="docutils literal"><span class="pre">list&lt;foo*&gt;</span></tt>) as if it were a container of the pointed-to type
+(e.g. <tt class="docutils literal"><span class="pre">list&lt;foo&gt;</span></tt>).  <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> depends on two
+auxiliary traits, <tt class="docutils literal"><span class="pre">pointee</span></tt> and <tt class="docutils literal"><span class="pre">indirect_reference</span></tt>, to
+provide support for underlying iterators whose <tt class="docutils literal"><span class="pre">value_type</span></tt> is
 not an iterator.</td>
 </tr>
 </tbody>
 </table>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
+<p class="topic-title first"><a name="table-of-contents">Table of Contents</a></p>
 <ul class="simple">
-<li><a class="reference" href="#indirect-iterator-synopsis" id="id2" name="id2"><tt class="literal"><span class="pre">indirect_iterator</span></tt> synopsis</a></li>
-<li><a class="reference" href="#indirect-iterator-requirements" id="id3" name="id3"><tt class="literal"><span class="pre">indirect_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#indirect-iterator-models" id="id4" name="id4"><tt class="literal"><span class="pre">indirect_iterator</span></tt> models</a></li>
-<li><a class="reference" href="#indirect-iterator-operations" id="id5" name="id5"><tt class="literal"><span class="pre">indirect_iterator</span></tt> operations</a></li>
+<li><a class="reference" href="#indirect-iterator-synopsis" id="id2" name="id2"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> synopsis</a></li>
+<li><a class="reference" href="#indirect-iterator-requirements" id="id3" name="id3"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> requirements</a></li>
+<li><a class="reference" href="#indirect-iterator-models" id="id4" name="id4"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> models</a></li>
+<li><a class="reference" href="#indirect-iterator-operations" id="id5" name="id5"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> operations</a></li>
 <li><a class="reference" href="#example" id="id6" name="id6">Example</a></li>
 </ul>
 </div>
 <div class="section" id="indirect-iterator-synopsis">
-<h1><a class="toc-backref" href="#id2" name="indirect-iterator-synopsis"><tt class="literal"><span class="pre">indirect_iterator</span></tt> synopsis</a></h1>
+<h1><a class="toc-backref" href="#id2" name="indirect-iterator-synopsis"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> synopsis</a></h1>
 <pre class="literal-block">
 template &lt;
     class Iterator
@@ -98,9 +98,9 @@ private:
    Iterator m_iterator; // exposition
 };
 </pre>
-<p>The member types of <tt class="literal"><span class="pre">indirect_iterator</span></tt> are defined according to
-the following pseudo-code, where <tt class="literal"><span class="pre">V</span></tt> is
-<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt></p>
+<p>The member types of <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> are defined according to
+the following pseudo-code, where <tt class="docutils literal"><span class="pre">V</span></tt> is
+<tt class="docutils literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt></p>
 <pre class="literal-block">
 if (Value is use_default) then
     typedef remove_const&lt;pointee&lt;V&gt;::type&gt;::type value_type;
@@ -136,64 +136,64 @@ else
 </pre>
 </div>
 <div class="section" id="indirect-iterator-requirements">
-<h1><a class="toc-backref" href="#id3" name="indirect-iterator-requirements"><tt class="literal"><span class="pre">indirect_iterator</span></tt> requirements</a></h1>
-<p>The expression <tt class="literal"><span class="pre">*v</span></tt>, where <tt class="literal"><span class="pre">v</span></tt> is an object of
-<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt>, shall be valid
-expression and convertible to <tt class="literal"><span class="pre">reference</span></tt>.  <tt class="literal"><span class="pre">Iterator</span></tt> shall
-model the traversal concept indicated by <tt class="literal"><span class="pre">iterator_category</span></tt>.
-<tt class="literal"><span class="pre">Value</span></tt>, <tt class="literal"><span class="pre">Reference</span></tt>, and <tt class="literal"><span class="pre">Difference</span></tt> shall be chosen so
-that <tt class="literal"><span class="pre">value_type</span></tt>, <tt class="literal"><span class="pre">reference</span></tt>, and <tt class="literal"><span class="pre">difference_type</span></tt> meet
-the requirements indicated by <tt class="literal"><span class="pre">iterator_category</span></tt>.</p>
+<h1><a class="toc-backref" href="#id3" name="indirect-iterator-requirements"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> requirements</a></h1>
+<p>The expression <tt class="docutils literal"><span class="pre">*v</span></tt>, where <tt class="docutils literal"><span class="pre">v</span></tt> is an object of
+<tt class="docutils literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt>, shall be valid
+expression and convertible to <tt class="docutils literal"><span class="pre">reference</span></tt>.  <tt class="docutils literal"><span class="pre">Iterator</span></tt> shall
+model the traversal concept indicated by <tt class="docutils literal"><span class="pre">iterator_category</span></tt>.
+<tt class="docutils literal"><span class="pre">Value</span></tt>, <tt class="docutils literal"><span class="pre">Reference</span></tt>, and <tt class="docutils literal"><span class="pre">Difference</span></tt> shall be chosen so
+that <tt class="docutils literal"><span class="pre">value_type</span></tt>, <tt class="docutils literal"><span class="pre">reference</span></tt>, and <tt class="docutils literal"><span class="pre">difference_type</span></tt> meet
+the requirements indicated by <tt class="docutils literal"><span class="pre">iterator_category</span></tt>.</p>
 <p>[Note: there are further requirements on the
-<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt> if the <tt class="literal"><span class="pre">Value</span></tt>
-parameter is not <tt class="literal"><span class="pre">use_default</span></tt>, as implied by the algorithm for
-deducing the default for the <tt class="literal"><span class="pre">value_type</span></tt> member.]</p>
+<tt class="docutils literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt> if the <tt class="docutils literal"><span class="pre">Value</span></tt>
+parameter is not <tt class="docutils literal"><span class="pre">use_default</span></tt>, as implied by the algorithm for
+deducing the default for the <tt class="docutils literal"><span class="pre">value_type</span></tt> member.]</p>
 </div>
 <div class="section" id="indirect-iterator-models">
-<h1><a class="toc-backref" href="#id4" name="indirect-iterator-models"><tt class="literal"><span class="pre">indirect_iterator</span></tt> models</a></h1>
-<p>In addition to the concepts indicated by <tt class="literal"><span class="pre">iterator_category</span></tt>
-and by <tt class="literal"><span class="pre">iterator_traversal&lt;indirect_iterator&gt;::type</span></tt>, a
-specialization of <tt class="literal"><span class="pre">indirect_iterator</span></tt> models the following
-concepts, Where <tt class="literal"><span class="pre">v</span></tt> is an object of
-<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt>:</p>
+<h1><a class="toc-backref" href="#id4" name="indirect-iterator-models"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> models</a></h1>
+<p>In addition to the concepts indicated by <tt class="docutils literal"><span class="pre">iterator_category</span></tt>
+and by <tt class="docutils literal"><span class="pre">iterator_traversal&lt;indirect_iterator&gt;::type</span></tt>, a
+specialization of <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> models the following
+concepts, Where <tt class="docutils literal"><span class="pre">v</span></tt> is an object of
+<tt class="docutils literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt>:</p>
 <blockquote>
 <ul class="simple">
-<li>Readable Iterator if <tt class="literal"><span class="pre">reference(*v)</span></tt> is convertible to
-<tt class="literal"><span class="pre">value_type</span></tt>.</li>
-<li>Writable Iterator if <tt class="literal"><span class="pre">reference(*v)</span> <span class="pre">=</span> <span class="pre">t</span></tt> is a valid
-expression (where <tt class="literal"><span class="pre">t</span></tt> is an object of type
-<tt class="literal"><span class="pre">indirect_iterator::value_type</span></tt>)</li>
-<li>Lvalue Iterator if <tt class="literal"><span class="pre">reference</span></tt> is a reference type.</li>
+<li>Readable Iterator if <tt class="docutils literal"><span class="pre">reference(*v)</span></tt> is convertible to
+<tt class="docutils literal"><span class="pre">value_type</span></tt>.</li>
+<li>Writable Iterator if <tt class="docutils literal"><span class="pre">reference(*v)</span> <span class="pre">=</span> <span class="pre">t</span></tt> is a valid
+expression (where <tt class="docutils literal"><span class="pre">t</span></tt> is an object of type
+<tt class="docutils literal"><span class="pre">indirect_iterator::value_type</span></tt>)</li>
+<li>Lvalue Iterator if <tt class="docutils literal"><span class="pre">reference</span></tt> is a reference type.</li>
 </ul>
 </blockquote>
-<p><tt class="literal"><span class="pre">indirect_iterator&lt;X,V1,C1,R1,D1&gt;</span></tt> is interoperable with
-<tt class="literal"><span class="pre">indirect_iterator&lt;Y,V2,C2,R2,D2&gt;</span></tt> if and only if <tt class="literal"><span class="pre">X</span></tt> is
-interoperable with <tt class="literal"><span class="pre">Y</span></tt>.</p>
+<p><tt class="docutils literal"><span class="pre">indirect_iterator&lt;X,V1,C1,R1,D1&gt;</span></tt> is interoperable with
+<tt class="docutils literal"><span class="pre">indirect_iterator&lt;Y,V2,C2,R2,D2&gt;</span></tt> if and only if <tt class="docutils literal"><span class="pre">X</span></tt> is
+interoperable with <tt class="docutils literal"><span class="pre">Y</span></tt>.</p>
 </div>
 <div class="section" id="indirect-iterator-operations">
-<h1><a class="toc-backref" href="#id5" name="indirect-iterator-operations"><tt class="literal"><span class="pre">indirect_iterator</span></tt> operations</a></h1>
+<h1><a class="toc-backref" href="#id5" name="indirect-iterator-operations"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> operations</a></h1>
 <p>In addition to the operations required by the concepts described
-above, specializations of <tt class="literal"><span class="pre">indirect_iterator</span></tt> provide the
+above, specializations of <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> provide the
 following operations.</p>
-<p><tt class="literal"><span class="pre">indirect_iterator();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">indirect_iterator();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">Iterator</span></tt> must be Default Constructible.</td>
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="docutils literal"><span class="pre">Iterator</span></tt> must be Default Constructible.</td>
 </tr>
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="literal"><span class="pre">indirect_iterator</span></tt> with 
-a default-constructed <tt class="literal"><span class="pre">m_iterator</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> with 
+a default-constructed <tt class="docutils literal"><span class="pre">m_iterator</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">indirect_iterator(Iterator</span> <span class="pre">x);</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">indirect_iterator(Iterator</span> <span class="pre">x);</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="literal"><span class="pre">indirect_iterator</span></tt> with
-<tt class="literal"><span class="pre">m_iterator</span></tt> copy constructed from <tt class="literal"><span class="pre">x</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> with
+<tt class="docutils literal"><span class="pre">m_iterator</span></tt> copy constructed from <tt class="docutils literal"><span class="pre">x</span></tt>.</td>
 </tr>
 </tbody>
 </table>
@@ -209,54 +209,54 @@ indirect_iterator(
   , typename enable_if_convertible&lt;Iterator2, Iterator&gt;::type* = 0 // exposition
 );
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">Iterator2</span></tt> is implicitly convertible to <tt class="literal"><span class="pre">Iterator</span></tt>.</td>
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="docutils literal"><span class="pre">Iterator2</span></tt> is implicitly convertible to <tt class="docutils literal"><span class="pre">Iterator</span></tt>.</td>
 </tr>
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="literal"><span class="pre">indirect_iterator</span></tt> whose 
-<tt class="literal"><span class="pre">m_iterator</span></tt> subobject is constructed from <tt class="literal"><span class="pre">y.base()</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> whose 
+<tt class="docutils literal"><span class="pre">m_iterator</span></tt> subobject is constructed from <tt class="docutils literal"><span class="pre">y.base()</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">Iterator</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">Iterator</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">m_iterator</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">**m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">**m_iterator</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">indirect_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">indirect_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">++m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">++m_iterator</span></tt></td>
 </tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*this</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">indirect_iterator&amp;</span> <span class="pre">operator--();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">indirect_iterator&amp;</span> <span class="pre">operator--();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">--m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">--m_iterator</span></tt></td>
 </tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*this</span></tt></td>
 </tr>
 </tbody>
 </table>
@@ -264,13 +264,13 @@ indirect_iterator(
 <div class="section" id="example">
 <h1><a class="toc-backref" href="#id6" name="example">Example</a></h1>
 <p>This example prints an array of characters, using
-<tt class="literal"><span class="pre">indirect_iterator</span></tt> to access the array of characters through an
-array of pointers. Next <tt class="literal"><span class="pre">indirect_iterator</span></tt> is used with the
-<tt class="literal"><span class="pre">transform</span></tt> algorithm to copy the characters (incremented by one) to
+<tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> to access the array of characters through an
+array of pointers. Next <tt class="docutils literal"><span class="pre">indirect_iterator</span></tt> is used with the
+<tt class="docutils literal"><span class="pre">transform</span></tt> algorithm to copy the characters (incremented by one) to
 another array. A constant indirect iterator is used for the source and
 a mutable indirect iterator is used for the destination. The last part
 of the example prints the original array of characters, but this time
-using the <tt class="literal"><span class="pre">make_indirect_iterator</span></tt> helper function.</p>
+using the <tt class="docutils literal"><span class="pre">make_indirect_iterator</span></tt> helper function.</p>
 <pre class="literal-block">
 char characters[] = &quot;abcdefg&quot;;
 const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
@@ -323,7 +323,7 @@ a,b,c,d,e,f,g,
 <p>The source code for this example can be found <a class="reference" href="../example/indirect_iterator_example.cpp">here</a>.</p>
 </div>
 </div>
-<hr class="footer" />
+<hr class="docutils footer" />
 <div class="footer">
 <a class="reference" href="indirect_iterator.rst">View document source</a>.
 Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.

doc/indirect_iterator.rst

@@ -8,7 +8,7 @@
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
 :date: $Date$
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu

doc/indirect_iterator_ref.html

@@ -0,0 +1,220 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title></title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<div class="document">
+<pre class="literal-block">
+template &lt;
+    class Iterator
+  , class Value = use_default
+  , class CategoryOrTraversal = use_default
+  , class Reference = use_default
+  , class Difference = use_default
+&gt;
+class indirect_iterator
+{
+ public:
+    typedef /* see below */ value_type;
+    typedef /* see below */ reference;
+    typedef /* see below */ pointer;
+    typedef /* see below */ difference_type;
+    typedef /* see below */ iterator_category;
+
+    indirect_iterator();
+    indirect_iterator(Iterator x);
+
+    template &lt;
+        class Iterator2, class Value2, class Category2
+      , class Reference2, class Difference2
+    &gt;
+    indirect_iterator(
+        indirect_iterator&lt;
+             Iterator2, Value2, Category2, Reference2, Difference2
+        &gt; const&amp; y
+      , typename enable_if_convertible&lt;Iterator2, Iterator&gt;::type* = 0 // exposition
+    );
+
+    Iterator const&amp; base() const;
+    reference operator*() const;
+    indirect_iterator&amp; operator++();
+    indirect_iterator&amp; operator--();
+private:
+   Iterator m_iterator; // exposition
+};
+</pre>
+<p>The member types of <tt class="literal"><span class="pre">indirect_iterator</span></tt> are defined according to
+the following pseudo-code, where <tt class="literal"><span class="pre">V</span></tt> is
+<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt></p>
+<pre class="literal-block">
+if (Value is use_default) then
+    typedef remove_const&lt;pointee&lt;V&gt;::type&gt;::type value_type;
+else
+    typedef remove_const&lt;Value&gt;::type value_type;
+
+if (Reference is use_default) then
+    if (Value is use_default) then
+        typedef indirect_reference&lt;V&gt;::type reference;
+    else
+        typedef Value&amp; reference;
+else
+    typedef Reference reference;
+
+if (Value is use_default) then 
+    typedef pointee&lt;V&gt;::type* pointer;
+else 
+    typedef Value* pointer;
+
+if (Difference is use_default)
+    typedef iterator_traits&lt;Iterator&gt;::difference_type difference_type;
+else
+    typedef Difference difference_type;
+
+if (CategoryOrTraversal is use_default)
+    typedef <em>iterator-category</em> (
+        iterator_traversal&lt;Iterator&gt;::type,``reference``,``value_type``
+    ) iterator_category;
+else
+    typedef <em>iterator-category</em> (
+        CategoryOrTraversal,``reference``,``value_type``
+    ) iterator_category;
+</pre>
+<div class="section" id="indirect-iterator-requirements">
+<h1><a name="indirect-iterator-requirements"><tt class="literal"><span class="pre">indirect_iterator</span></tt> requirements</a></h1>
+<p>The expression <tt class="literal"><span class="pre">*v</span></tt>, where <tt class="literal"><span class="pre">v</span></tt> is an object of
+<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt>, shall be valid
+expression and convertible to <tt class="literal"><span class="pre">reference</span></tt>.  <tt class="literal"><span class="pre">Iterator</span></tt> shall
+model the traversal concept indicated by <tt class="literal"><span class="pre">iterator_category</span></tt>.
+<tt class="literal"><span class="pre">Value</span></tt>, <tt class="literal"><span class="pre">Reference</span></tt>, and <tt class="literal"><span class="pre">Difference</span></tt> shall be chosen so
+that <tt class="literal"><span class="pre">value_type</span></tt>, <tt class="literal"><span class="pre">reference</span></tt>, and <tt class="literal"><span class="pre">difference_type</span></tt> meet
+the requirements indicated by <tt class="literal"><span class="pre">iterator_category</span></tt>.</p>
+<p>[Note: there are further requirements on the
+<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt> if the <tt class="literal"><span class="pre">Value</span></tt>
+parameter is not <tt class="literal"><span class="pre">use_default</span></tt>, as implied by the algorithm for
+deducing the default for the <tt class="literal"><span class="pre">value_type</span></tt> member.]</p>
+</div>
+<div class="section" id="indirect-iterator-models">
+<h1><a name="indirect-iterator-models"><tt class="literal"><span class="pre">indirect_iterator</span></tt> models</a></h1>
+<p>In addition to the concepts indicated by <tt class="literal"><span class="pre">iterator_category</span></tt>
+and by <tt class="literal"><span class="pre">iterator_traversal&lt;indirect_iterator&gt;::type</span></tt>, a
+specialization of <tt class="literal"><span class="pre">indirect_iterator</span></tt> models the following
+concepts, Where <tt class="literal"><span class="pre">v</span></tt> is an object of
+<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt>:</p>
+<blockquote>
+<ul class="simple">
+<li>Readable Iterator if <tt class="literal"><span class="pre">reference(*v)</span></tt> is convertible to
+<tt class="literal"><span class="pre">value_type</span></tt>.</li>
+<li>Writable Iterator if <tt class="literal"><span class="pre">reference(*v)</span> <span class="pre">=</span> <span class="pre">t</span></tt> is a valid
+expression (where <tt class="literal"><span class="pre">t</span></tt> is an object of type
+<tt class="literal"><span class="pre">indirect_iterator::value_type</span></tt>)</li>
+<li>Lvalue Iterator if <tt class="literal"><span class="pre">reference</span></tt> is a reference type.</li>
+</ul>
+</blockquote>
+<p><tt class="literal"><span class="pre">indirect_iterator&lt;X,V1,C1,R1,D1&gt;</span></tt> is interoperable with
+<tt class="literal"><span class="pre">indirect_iterator&lt;Y,V2,C2,R2,D2&gt;</span></tt> if and only if <tt class="literal"><span class="pre">X</span></tt> is
+interoperable with <tt class="literal"><span class="pre">Y</span></tt>.</p>
+</div>
+<div class="section" id="indirect-iterator-operations">
+<h1><a name="indirect-iterator-operations"><tt class="literal"><span class="pre">indirect_iterator</span></tt> operations</a></h1>
+<p>In addition to the operations required by the concepts described
+above, specializations of <tt class="literal"><span class="pre">indirect_iterator</span></tt> provide the
+following operations.</p>
+<p><tt class="literal"><span class="pre">indirect_iterator();</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">Iterator</span></tt> must be Default Constructible.</td>
+</tr>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="literal"><span class="pre">indirect_iterator</span></tt> with 
+a default-constructed <tt class="literal"><span class="pre">m_iterator</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">indirect_iterator(Iterator</span> <span class="pre">x);</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="literal"><span class="pre">indirect_iterator</span></tt> with
+<tt class="literal"><span class="pre">m_iterator</span></tt> copy constructed from <tt class="literal"><span class="pre">x</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+<pre class="literal-block">
+template &lt;
+    class Iterator2, class Value2, unsigned Access, class Traversal
+  , class Reference2, class Difference2
+&gt;
+indirect_iterator(
+    indirect_iterator&lt;
+         Iterator2, Value2, Access, Traversal, Reference2, Difference2
+    &gt; const&amp; y
+  , typename enable_if_convertible&lt;Iterator2, Iterator&gt;::type* = 0 // exposition
+);
+</pre>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">Iterator2</span></tt> is implicitly convertible to <tt class="literal"><span class="pre">Iterator</span></tt>.</td>
+</tr>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="literal"><span class="pre">indirect_iterator</span></tt> whose 
+<tt class="literal"><span class="pre">m_iterator</span></tt> subobject is constructed from <tt class="literal"><span class="pre">y.base()</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">Iterator</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">**m_iterator</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">indirect_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">++m_iterator</span></tt></td>
+</tr>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">indirect_iterator&amp;</span> <span class="pre">operator--();</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">--m_iterator</span></tt></td>
+</tr>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="indirect_iterator_ref.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/interoperability-revisited.rst

@@ -67,7 +67,7 @@ Mutable  m;
 c == m; // ok, dispatched to Constant::equal_to
 m == c; // !! error, dispatched to Mutable::equal_to
 
-Instead the following "slightly" more complicated implementation is neccessary
+Instead the following "slightly" more complicated implementation is necessary
 
 struct Mutable : Facade<Mutable>
 {
@@ -87,7 +87,7 @@ struct Constant : Tag<Constant>
 
 Beside the fact that the code is significantly more complex to understand and to teach there is
 a major design problem lurking here. Note that in both types equal_to is a function template with 
-an unconstrained argument T. This is neccessary so that further types can be made interoperable with
+an unconstrained argument T. This is necessary so that further types can be made interoperable with
 Mutable or Constant. Would Mutable be defined as  
 
 struct Mutable : Facade<Mutable>
@@ -229,4 +229,4 @@ Iterator implementations using iterator_facade look exactly as if they were
 a) Less burden for the user
 
 b) The definition (standardese) of specialized adpters might be easier 
-   (This has to be proved yet)
+   (This has to be proved yet)

doc/issues.html

@@ -3,13 +3,13 @@
 <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.2.8: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.6: http://docutils.sourceforge.net/" />
 <title>Problem with is_writable and is_swappable in N1550</title>
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
-<div class="document" id="problem-with-is-writable-and-is-swappable-in-n1550">
 <h1 class="title">Problem with <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> in <a class="reference" href="http://www.boost-consulting.com/writing/n1550.html">N1550</a></h1>
+<div class="document" id="problem-with-is-writable-and-is-swappable-in-n1550">
 <table class="field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
@@ -30,7 +30,7 @@ at <a class="reference" href="http://www.boost.org/LICENSE_1_0.txt">http://www.b
 </tbody>
 </table>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
+<p class="topic-title first"><a name="table-of-contents">Table of Contents</a></p>
 <ul class="simple">
 <li><a class="reference" href="#introduction" id="id1" name="id1">Introduction</a></li>
 <li><a class="reference" href="#proposed-resolution" id="id2" name="id2">Proposed Resolution</a></li>
@@ -161,5 +161,10 @@ direct result of the removal of <tt class="literal"><span class="pre">iterator_t
 </ol>
 </div>
 </div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="issues.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
 </body>
 </html>

doc/iter-issue-list.rst

@@ -3,7 +3,6 @@
 +++++++++++++++++++++++++++++++++++++
 
 :date: $Date$
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.
 
 .. contents:: Index
 
@@ -1834,6 +1833,15 @@ to assign through a dereferenced iterator that f(x) has to work,
 and then only for the particular function object that the iterator
 holds and for the particular value that is being assigned.
 
+
+Addition from Jeremy:
+  The constructor for ``function_output_iterator`` is also
+  slightly overconstrained because it requires 
+  the ``UnaryFunction`` to have a default constructor
+  even when the default constructor of ``function_output_iterator``
+  is not used.
+
+
 :Proposed resolution: 
 
   Change:
@@ -1904,6 +1912,17 @@ holds and for the particular value that is being assigned.
           return *this; 
 
 
+  Change::
+
+    explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());
+
+  to::
+
+    explicit function_output_iterator();
+
+    explicit function_output_iterator(const UnaryFunction& f);
+
+
 
 9.32 Should output_proxy really be a named type? 
 ================================================
@@ -2017,6 +2036,10 @@ c++std-lib-12333:
     +-------------+-----------+-----------------------------------+
 
 
+  At the end of the section reverse_iterator models, add:
+  The type ``iterator_traits<Iterator>::reference`` must be the type of
+  ``*i``, where ``i`` is an object of type ``Iterator``.
+
 
 :Rationale: Ideally there should be requirements on the reference
   type, however, since Readable Iterator is suppose to correspond
@@ -3557,6 +3580,23 @@ this issue.
 
    :Proposed resolution: add "from" before "making"
 
+2. mention of obsolete projection_iterator
+
+  :Proposed Resolution:
+
+    From n1530, in the **Specialized Adaptors** section, remove:
+
+      ``projection_iterator``, which is similar to ``transform_iterator``
+      except that when dereferenced it returns a reference instead of
+      a value.
+
+  :Rationale:
+    This iterator was in the original boost library, but the new
+    iterator concepts allowed this iterator to be
+    folded into ``transform_iterator``.
+
+
+
 9.46y N1530: ``base()`` return-by-value is costly
 =================================================
 
@@ -3796,3 +3836,6 @@ to:
   |``c.distance_to(z)``|convertible to        |equivalent to            |Random Access Traversal    |
   |                    |``F::difference_type``|``distance(c, X(z))``.   |Iterator                   |
   +--------------------+----------------------+-------------------------+---------------------------+
+
+
+

doc/iterator_adaptor.html

@@ -3,12 +3,12 @@
 <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.3.0: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.8: http://docutils.sourceforge.net/" />
 <title>Iterator Adaptor</title>
 <meta name="author" content="David Abrahams, Jeremy Siek, Thomas Witt" />
 <meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab, University of Hanover Institute for Transport Railway Operation and Construction" />
-<meta name="date" content="2004-01-12" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003." />
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
@@ -27,12 +27,12 @@
 Lab</a>, University of Hanover <a class="last reference" href="http://www.ive.uni-hannover.de">Institute for Transport
 Railway Operation and Construction</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2004-01-12</td></tr>
+<td>2004-11-01</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
+<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.</td></tr>
 </tbody>
 </table>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
@@ -42,28 +42,27 @@ Railway Operation and Construction</a></td></tr>
 </table>
 <!-- Version 1.1 of this ReStructuredText document corresponds to
 n1530_, the paper accepted by the LWG. -->
-<!-- Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All
-rights reserved -->
-<p>Each specialization of the <tt class="literal"><span class="pre">iterator_adaptor</span></tt> class template is derived from
-a specialization of <tt class="literal"><span class="pre">iterator_facade</span></tt>. The core interface functions
-expected by <tt class="literal"><span class="pre">iterator_facade</span></tt> are implemented in terms of the
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt>'s <tt class="literal"><span class="pre">Base</span></tt> template parameter. A class derived
-from <tt class="literal"><span class="pre">iterator_adaptor</span></tt> typically redefines some of the core
-interface functions to adapt the behavior of the <tt class="literal"><span class="pre">Base</span></tt> type.
+<!-- Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.  -->
+<p>Each specialization of the <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> class template is derived from
+a specialization of <tt class="docutils literal"><span class="pre">iterator_facade</span></tt>. The core interface functions
+expected by <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> are implemented in terms of the
+<tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>'s <tt class="docutils literal"><span class="pre">Base</span></tt> template parameter. A class derived
+from <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> typically redefines some of the core
+interface functions to adapt the behavior of the <tt class="docutils literal"><span class="pre">Base</span></tt> type.
 Whether the derived class models any of the standard iterator concepts
-depends on the operations supported by the <tt class="literal"><span class="pre">Base</span></tt> type and which
-core interface functions of <tt class="literal"><span class="pre">iterator_facade</span></tt> are redefined in the
-<tt class="literal"><span class="pre">Derived</span></tt> class.</p>
+depends on the operations supported by the <tt class="docutils literal"><span class="pre">Base</span></tt> type and which
+core interface functions of <tt class="docutils literal"><span class="pre">iterator_facade</span></tt> are redefined in the
+<tt class="docutils literal"><span class="pre">Derived</span></tt> class.</p>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
+<p class="topic-title first"><a name="table-of-contents">Table of Contents</a></p>
 <ul class="simple">
 <li><a class="reference" href="#overview" id="id6" name="id6">Overview</a></li>
 <li><a class="reference" href="#reference" id="id7" name="id7">Reference</a><ul>
-<li><a class="reference" href="#iterator-adaptor-requirements" id="id8" name="id8"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> requirements</a></li>
-<li><a class="reference" href="#iterator-adaptor-base-class-parameters" id="id9" name="id9"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> base class parameters</a></li>
-<li><a class="reference" href="#iterator-adaptor-public-operations" id="id10" name="id10"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> public operations</a></li>
-<li><a class="reference" href="#iterator-adaptor-protected-member-functions" id="id11" name="id11"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> protected member functions</a></li>
-<li><a class="reference" href="#iterator-adaptor-private-member-functions" id="id12" name="id12"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> private member functions</a></li>
+<li><a class="reference" href="#iterator-adaptor-requirements" id="id8" name="id8"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> requirements</a></li>
+<li><a class="reference" href="#iterator-adaptor-base-class-parameters" id="id9" name="id9"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> base class parameters</a></li>
+<li><a class="reference" href="#iterator-adaptor-public-operations" id="id10" name="id10"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> public operations</a></li>
+<li><a class="reference" href="#iterator-adaptor-protected-member-functions" id="id11" name="id11"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> protected member functions</a></li>
+<li><a class="reference" href="#iterator-adaptor-private-member-functions" id="id12" name="id12"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> private member functions</a></li>
 </ul>
 </li>
 <li><a class="reference" href="#tutorial-example" id="id13" name="id13">Tutorial Example</a></li>
@@ -73,49 +72,48 @@ core interface functions of <tt class="literal"><span class="pre">iterator_facad
 <h1><a class="toc-backref" href="#id6" name="overview">Overview</a></h1>
 <!-- Version 1.2 of this ReStructuredText document corresponds to
 n1530_, the paper accepted by the LWG for TR1. -->
-<!-- Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All
-rights reserved -->
-<p>The <tt class="literal"><span class="pre">iterator_adaptor</span></tt> class template adapts some <tt class="literal"><span class="pre">Base</span></tt> <a class="footnote-reference" href="#base" id="id1" name="id1"><sup>1</sup></a>
-type to create a new iterator.  Instantiations of <tt class="literal"><span class="pre">iterator_adaptor</span></tt>
-are derived from a corresponding instantiation of <tt class="literal"><span class="pre">iterator_facade</span></tt>
-and implement the core behaviors in terms of the <tt class="literal"><span class="pre">Base</span></tt> type. In
-essence, <tt class="literal"><span class="pre">iterator_adaptor</span></tt> merely forwards all operations to an
-instance of the <tt class="literal"><span class="pre">Base</span></tt> type, which it stores as a member.</p>
-<table class="footnote" frame="void" id="base" rules="none">
+<!-- Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.  -->
+<p>The <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> class template adapts some <tt class="docutils literal"><span class="pre">Base</span></tt> <a class="footnote-reference" href="#base" id="id1" name="id1">[1]</a>
+type to create a new iterator.  Instantiations of <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>
+are derived from a corresponding instantiation of <tt class="docutils literal"><span class="pre">iterator_facade</span></tt>
+and implement the core behaviors in terms of the <tt class="docutils literal"><span class="pre">Base</span></tt> type. In
+essence, <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> merely forwards all operations to an
+instance of the <tt class="docutils literal"><span class="pre">Base</span></tt> type, which it stores as a member.</p>
+<table class="docutils footnote" frame="void" id="base" rules="none">
 <colgroup><col class="label" /><col /></colgroup>
 <tbody valign="top">
 <tr><td class="label"><a name="base">[1]</a></td><td><em>(<a class="fn-backref" href="#id1">1</a>, <a class="fn-backref" href="#id3">2</a>)</em> The term &quot;Base&quot; here does not refer to a base class and is
 not meant to imply the use of derivation. We have followed the lead
 of the standard library, which provides a base() function to access
-the underlying iterator object of a <tt class="literal"><span class="pre">reverse_iterator</span></tt> adaptor.</td></tr>
+the underlying iterator object of a <tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> adaptor.</td></tr>
 </tbody>
 </table>
-<p>The user of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> creates a class derived from an
-instantiation of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> and then selectively
-redefines some of the core member functions described in the table
-above. The <tt class="literal"><span class="pre">Base</span></tt> type need not meet the full requirements for an
-iterator. It need only support the operations used by the core
-interface functions of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> that have not been
-redefined in the user's derived class.</p>
-<p>Several of the template parameters of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> default
-to <tt class="literal"><span class="pre">use_default</span></tt>. This allows the
+<p>The user of <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> creates a class derived from an
+instantiation of <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> and then selectively
+redefines some of the core member functions described in the
+<tt class="docutils literal"><span class="pre">iterator_facade</span></tt> core requirements table. The <tt class="docutils literal"><span class="pre">Base</span></tt> type need
+not meet the full requirements for an iterator; it need only
+support the operations used by the core interface functions of
+<tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> that have not been redefined in the user's
+derived class.</p>
+<p>Several of the template parameters of <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> default
+to <tt class="docutils literal"><span class="pre">use_default</span></tt>. This allows the
 user to make use of a default parameter even when she wants to
 specify a parameter later in the parameter list.  Also, the
 defaults for the corresponding associated types are somewhat
 complicated, so metaprogramming is required to compute them, and
-<tt class="literal"><span class="pre">use_default</span></tt> can help to simplify the implementation.  Finally,
-the identity of the <tt class="literal"><span class="pre">use_default</span></tt> type is not left unspecified
-because specification helps to highlight that the <tt class="literal"><span class="pre">Reference</span></tt>
+<tt class="docutils literal"><span class="pre">use_default</span></tt> can help to simplify the implementation.  Finally,
+the identity of the <tt class="docutils literal"><span class="pre">use_default</span></tt> type is not left unspecified
+because specification helps to highlight that the <tt class="docutils literal"><span class="pre">Reference</span></tt>
 template parameter may not always be identical to the iterator's
-<tt class="literal"><span class="pre">reference</span></tt> type, and will keep users from making mistakes based on
+<tt class="docutils literal"><span class="pre">reference</span></tt> type, and will keep users from making mistakes based on
 that assumption.</p>
 </div>
 <div class="section" id="reference">
 <h1><a class="toc-backref" href="#id7" name="reference">Reference</a></h1>
 <!-- Version 1.4 of this ReStructuredText document corresponds to
 n1530_, the paper accepted by the LWG for TR1. -->
-<!-- Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All
-rights reserved. -->
+<!-- Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.  -->
 <pre class="literal-block">
 template &lt;
     class Derived
@@ -131,9 +129,11 @@ class iterator_adaptor
     friend class iterator_core_access;
  public:
     iterator_adaptor();
-    explicit iterator_adaptor(Base iter);
+    explicit iterator_adaptor(Base const&amp; iter);
+    typedef Base base_type;
     Base const&amp; base() const;
  protected:
+    typedef iterator_adaptor iterator_adaptor_;
     Base const&amp; base_reference() const;
     Base&amp; base_reference();
  private: // Core iterator interface for iterator_facade.  
@@ -159,14 +159,14 @@ class iterator_adaptor
 };
 </pre>
 <a class="target" id="requirements" name="requirements"></a><div class="section" id="iterator-adaptor-requirements">
-<h2><a class="toc-backref" href="#id8" name="iterator-adaptor-requirements"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> requirements</a></h2>
-<p><tt class="literal"><span class="pre">static_cast&lt;Derived*&gt;(iterator_adaptor*)</span></tt> shall be well-formed.
-The <tt class="literal"><span class="pre">Base</span></tt> argument shall be Assignable and Copy Constructible.</p>
+<h2><a class="toc-backref" href="#id8" name="iterator-adaptor-requirements"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> requirements</a></h2>
+<p><tt class="docutils literal"><span class="pre">static_cast&lt;Derived*&gt;(iterator_adaptor*)</span></tt> shall be well-formed.
+The <tt class="docutils literal"><span class="pre">Base</span></tt> argument shall be Assignable and Copy Constructible.</p>
 <a class="target" id="base-parameters" name="base-parameters"></a></div>
 <div class="section" id="iterator-adaptor-base-class-parameters">
-<h2><a class="toc-backref" href="#id9" name="iterator-adaptor-base-class-parameters"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> base class parameters</a></h2>
-<p>The <em>V'</em>, <em>C'</em>, <em>R'</em>, and <em>D'</em> parameters of the <tt class="literal"><span class="pre">iterator_facade</span></tt>
-used as a base class in the summary of <tt class="literal"><span class="pre">iterator_adaptor</span></tt>
+<h2><a class="toc-backref" href="#id9" name="iterator-adaptor-base-class-parameters"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> base class parameters</a></h2>
+<p>The <em>V'</em>, <em>C'</em>, <em>R'</em>, and <em>D'</em> parameters of the <tt class="docutils literal"><span class="pre">iterator_facade</span></tt>
+used as a base class in the summary of <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>
 above are defined as follows:</p>
 <pre class="literal-block">
 <em>V'</em> = if (Value is use_default)
@@ -205,68 +205,68 @@ expression involving ``Derived`` in those concepts' requirements. -->
 <!-- That's why it's removed.  We're embracing inheritance, remember? -->
 </div>
 <div class="section" id="iterator-adaptor-public-operations">
-<h2><a class="toc-backref" href="#id10" name="iterator-adaptor-public-operations"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> public operations</a></h2>
-<p><tt class="literal"><span class="pre">iterator_adaptor();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<h2><a class="toc-backref" href="#id10" name="iterator-adaptor-public-operations"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> public operations</a></h2>
+<p><tt class="docutils literal"><span class="pre">iterator_adaptor();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Requires:</th><td class="field-body">The <tt class="literal"><span class="pre">Base</span></tt> type must be Default Constructible.</td>
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body">The <tt class="docutils literal"><span class="pre">Base</span></tt> type must be Default Constructible.</td>
 </tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> with 
-<tt class="literal"><span class="pre">m_iterator</span></tt> default constructed.</td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> with 
+<tt class="docutils literal"><span class="pre">m_iterator</span></tt> default constructed.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">explicit</span> <span class="pre">iterator_adaptor(Base</span> <span class="pre">iter);</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">explicit</span> <span class="pre">iterator_adaptor(Base</span> <span class="pre">const&amp;</span> <span class="pre">iter);</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> with
-<tt class="literal"><span class="pre">m_iterator</span></tt> copy constructed from <tt class="literal"><span class="pre">iter</span></tt>.</td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> with
+<tt class="docutils literal"><span class="pre">m_iterator</span></tt> copy constructed from <tt class="docutils literal"><span class="pre">iter</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">Base</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">Base</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">m_iterator</span></tt></td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="iterator-adaptor-protected-member-functions">
-<h2><a class="toc-backref" href="#id11" name="iterator-adaptor-protected-member-functions"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> protected member functions</a></h2>
-<p><tt class="literal"><span class="pre">Base</span> <span class="pre">const&amp;</span> <span class="pre">base_reference()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<h2><a class="toc-backref" href="#id11" name="iterator-adaptor-protected-member-functions"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> protected member functions</a></h2>
+<p><tt class="docutils literal"><span class="pre">Base</span> <span class="pre">const&amp;</span> <span class="pre">base_reference()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A const reference to <tt class="literal"><span class="pre">m_iterator</span></tt>.</td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A const reference to <tt class="docutils literal"><span class="pre">m_iterator</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">Base&amp;</span> <span class="pre">base_reference();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">Base&amp;</span> <span class="pre">base_reference();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A non-const reference to <tt class="literal"><span class="pre">m_iterator</span></tt>.</td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A non-const reference to <tt class="docutils literal"><span class="pre">m_iterator</span></tt>.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="iterator-adaptor-private-member-functions">
-<h2><a class="toc-backref" href="#id12" name="iterator-adaptor-private-member-functions"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> private member functions</a></h2>
-<p><tt class="literal"><span class="pre">typename</span> <span class="pre">iterator_adaptor::reference</span> <span class="pre">dereference()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<h2><a class="toc-backref" href="#id12" name="iterator-adaptor-private-member-functions"><tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> private member functions</a></h2>
+<p><tt class="docutils literal"><span class="pre">typename</span> <span class="pre">iterator_adaptor::reference</span> <span class="pre">dereference()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*m_iterator</span></tt></td>
 </tr>
 </tbody>
 </table>
@@ -276,38 +276,38 @@ class OtherDerived, class OtherIterator, class V, class C, class R, class D
 &gt;   
 bool equal(iterator_adaptor&lt;OtherDerived, OtherIterator, V, C, R, D&gt; const&amp; x) const;
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span> <span class="pre">==</span> <span class="pre">x.base()</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">m_iterator</span> <span class="pre">==</span> <span class="pre">x.base()</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">void</span> <span class="pre">advance(typename</span> <span class="pre">iterator_adaptor::difference_type</span> <span class="pre">n);</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">void</span> <span class="pre">advance(typename</span> <span class="pre">iterator_adaptor::difference_type</span> <span class="pre">n);</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span> <span class="pre">+=</span> <span class="pre">n;</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">m_iterator</span> <span class="pre">+=</span> <span class="pre">n;</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">void</span> <span class="pre">increment();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">void</span> <span class="pre">increment();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">++m_iterator;</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">++m_iterator;</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">void</span> <span class="pre">decrement();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">void</span> <span class="pre">decrement();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">--m_iterator;</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">--m_iterator;</span></tt></td>
 </tr>
 </tbody>
 </table>
@@ -318,11 +318,11 @@ template &lt;
 typename iterator_adaptor::difference_type distance_to(
     iterator_adaptor&lt;OtherDerived, OtherIterator, V, C, R, D&gt; const&amp; y) const;
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">y.base()</span> <span class="pre">-</span> <span class="pre">m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">y.base()</span> <span class="pre">-</span> <span class="pre">m_iterator</span></tt></td>
 </tr>
 </tbody>
 </table>
@@ -333,43 +333,44 @@ typename iterator_adaptor::difference_type distance_to(
 <!-- 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) -->
-<p>In this section we'll further refine the <tt class="literal"><span class="pre">node_iter</span></tt> class
-template we developed in the <a class="reference" href="iterator_facade.html#tutorial-example"><tt class="literal"><span class="pre">iterator_facade</span></tt> tutorial</a>.  If you haven't already
+<p>In this section we'll further refine the <tt class="docutils literal"><span class="pre">node_iter</span></tt> class
+template we developed in the <a class="reference" href="iterator_facade.html#tutorial-example"><tt class="docutils literal"><span class="pre">iterator_facade</span></tt> tutorial</a>.  If you haven't already
 read that material, you should go back now and check it out because
 we're going to pick up right where it left off.</p>
 <div class="sidebar">
-<p class="sidebar-title"><tt class="literal"><span class="pre">node_base*</span></tt> really <em>is</em> an iterator</p>
-<p>It's not really a very interesting iterator, since <tt class="literal"><span class="pre">node_base</span></tt>
-is an abstract class: a pointer to a <tt class="literal"><span class="pre">node_base</span></tt> just points
+<p class="first sidebar-title"><tt class="docutils literal"><span class="pre">node_base*</span></tt> really <em>is</em> an iterator</p>
+<p class="last">It's not really a very interesting iterator, since <tt class="docutils literal"><span class="pre">node_base</span></tt>
+is an abstract class: a pointer to a <tt class="docutils literal"><span class="pre">node_base</span></tt> just points
 at some base subobject of an instance of some other class, and
-incrementing a <tt class="literal"><span class="pre">node_base*</span></tt> moves it past this base subobject
+incrementing a <tt class="docutils literal"><span class="pre">node_base*</span></tt> moves it past this base subobject
 to who-knows-where?  The most we can do with that incremented
-position is to compare another <tt class="literal"><span class="pre">node_base*</span></tt> to it.  In other
+position is to compare another <tt class="docutils literal"><span class="pre">node_base*</span></tt> to it.  In other
 words, the original iterator traverses a one-element array.</p>
 </div>
-<p>You probably didn't think of it this way, but the <tt class="literal"><span class="pre">node_base*</span></tt>
-object which underlies <tt class="literal"><span class="pre">node_iterator</span></tt> is itself an iterator,
+<p>You probably didn't think of it this way, but the <tt class="docutils literal"><span class="pre">node_base*</span></tt>
+object that underlies <tt class="docutils literal"><span class="pre">node_iterator</span></tt> is itself an iterator,
 just like all other pointers.  If we examine that pointer closely
 from an iterator perspective, we can see that it has much in common
-with the <tt class="literal"><span class="pre">node_iterator</span></tt> we're building.  First, they share most
-of the same associated types (<tt class="literal"><span class="pre">value_type</span></tt>, <tt class="literal"><span class="pre">reference</span></tt>,
-<tt class="literal"><span class="pre">pointer</span></tt>, and <tt class="literal"><span class="pre">difference_type</span></tt>).  Second, even some of the
-core functionality is the same: <tt class="literal"><span class="pre">operator*</span></tt> and <tt class="literal"><span class="pre">operator==</span></tt> on
-the <tt class="literal"><span class="pre">node_iterator</span></tt> return the result of invoking the same
-operations on the underlying pointer, via the <tt class="literal"><span class="pre">node_iterator</span></tt>'s
-<a class="reference" href="iterator_facade.html#implementing-the-core-operations"><tt class="literal"><span class="pre">dereference</span></tt> and <tt class="literal"><span class="pre">equal</span></tt> member functions</a>). However, the <tt class="literal"><span class="pre">operator++</span></tt> for
-<tt class="literal"><span class="pre">node_iterator</span></tt> behaves differently than for <tt class="literal"><span class="pre">node_base*</span></tt>
-since it follows the <tt class="literal"><span class="pre">m_next</span></tt> pointer.</p>
+with the <tt class="docutils literal"><span class="pre">node_iterator</span></tt> we're building.  First, they share most
+of the same associated types (<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>, and <tt class="docutils literal"><span class="pre">difference_type</span></tt>).  Second, even some of the
+core functionality is the same: <tt class="docutils literal"><span class="pre">operator*</span></tt> and <tt class="docutils literal"><span class="pre">operator==</span></tt> on
+the <tt class="docutils literal"><span class="pre">node_iterator</span></tt> return the result of invoking the same
+operations on the underlying pointer, via the <tt class="docutils literal"><span class="pre">node_iterator</span></tt>'s
+<a class="reference" href="iterator_facade.html#implementing-the-core-operations"><tt class="docutils literal"><span class="pre">dereference</span></tt> and <tt class="docutils literal"><span class="pre">equal</span></tt> member functions</a>).  The only real behavioral difference
+between <tt class="docutils literal"><span class="pre">node_base*</span></tt> and <tt class="docutils literal"><span class="pre">node_iterator</span></tt> can be observed when
+they are incremented: <tt class="docutils literal"><span class="pre">node_iterator</span></tt> follows the
+<tt class="docutils literal"><span class="pre">m_next</span></tt> pointer, while <tt class="docutils literal"><span class="pre">node_base*</span></tt> just applies an address offset.</p>
 <p>It turns out that the pattern of building an iterator on another
-iterator-like type (the <tt class="literal"><span class="pre">Base</span></tt> <a class="footnote-reference" href="#base" id="id3" name="id3"><sup>1</sup></a> type) while modifying
+iterator-like type (the <tt class="docutils literal"><span class="pre">Base</span></tt> <a class="footnote-reference" href="#base" id="id3" name="id3">[1]</a> type) while modifying
 just a few aspects of the underlying type's behavior is an
 extremely common one, and it's the pattern addressed by
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt>.  Using <tt class="literal"><span class="pre">iterator_adaptor</span></tt> is very much like
-using <tt class="literal"><span class="pre">iterator_facade</span></tt>, but because iterator_adaptor tries to
-mimic as much of the <tt class="literal"><span class="pre">Base</span></tt> type's behavior as possible, we
-neither have to supply a <tt class="literal"><span class="pre">Value</span></tt> argument, nor implement any core
-behaviors other than <tt class="literal"><span class="pre">increment</span></tt>.  The implementation of
-<tt class="literal"><span class="pre">node_iter</span></tt> is thus reduced to:</p>
+<tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>.  Using <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> is very much like
+using <tt class="docutils literal"><span class="pre">iterator_facade</span></tt>, but because iterator_adaptor tries to
+mimic as much of the <tt class="docutils literal"><span class="pre">Base</span></tt> type's behavior as possible, we
+neither have to supply a <tt class="docutils literal"><span class="pre">Value</span></tt> argument, nor implement any core
+behaviors other than <tt class="docutils literal"><span class="pre">increment</span></tt>.  The implementation of
+<tt class="docutils literal"><span class="pre">node_iter</span></tt> is thus reduced to:</p>
 <pre class="literal-block">
 template &lt;class Value&gt;
 class node_iter
@@ -383,16 +384,12 @@ class node_iter
  private:
     struct enabler {};  // a private type avoids misuse
 
-    typedef boost::iterator_adaptor&lt;
-        node_iter&lt;Value&gt;, Value*, boost::use_default, boost::forward_traversal_tag
-    &gt; super_t;
-
  public:
     node_iter()
-      : super_t(0) {}
+      : node_iter::iterator_adaptor_(0) {}
 
     explicit node_iter(Value* p)
-      : super_t(p) {}
+      : node_iter::iterator_adaptor_(p) {}
 
     template &lt;class OtherValue&gt;
     node_iter(
@@ -402,39 +399,50 @@ class node_iter
           , enabler
         &gt;::type = enabler()
     )
-      : super_t(other.base()) {}
+      : node_iter::iterator_adaptor_(other.base()) {}
 
  private:
     friend class boost::iterator_core_access;
     void increment() { this-&gt;base_reference() = this-&gt;base()-&gt;next(); }
 };
 </pre>
-<p>You can see an example program which exercises this version of the
+<p>Note the use of <tt class="docutils literal"><span class="pre">node_iter::iterator_adaptor_</span></tt> here: because
+<tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> defines a nested <tt class="docutils literal"><span class="pre">iterator_adaptor_</span></tt> type
+that refers to itself, that gives us a convenient way to refer to
+the complicated base class type of <tt class="docutils literal"><span class="pre">node_iter&lt;Value&gt;</span></tt>. [Note:
+this technique is known not to work with Borland C++ 5.6.4 and
+Metrowerks CodeWarrior versions prior to 9.0]</p>
+<p>You can see an example program that exercises this version of the
 node iterators <a class="reference" href="../example/node_iterator3.cpp">here</a>.</p>
-<p>In the case of <tt class="literal"><span class="pre">node_iter</span></tt>, it's not very compelling to pass
-<tt class="literal"><span class="pre">boost::use_default</span></tt> as <tt class="literal"><span class="pre">iterator_adaptor</span></tt>'s <tt class="literal"><span class="pre">Value</span></tt>
-argument; we could have just passed <tt class="literal"><span class="pre">node_iter</span></tt>'s <tt class="literal"><span class="pre">Value</span></tt>
-along to <tt class="literal"><span class="pre">iterator_adaptor</span></tt>, and that'd even be shorter!  Most
-iterator class templates built with <tt class="literal"><span class="pre">iterator_adaptor</span></tt> are
+<p>In the case of <tt class="docutils literal"><span class="pre">node_iter</span></tt>, it's not very compelling to pass
+<tt class="docutils literal"><span class="pre">boost::use_default</span></tt> as <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>'s <tt class="docutils literal"><span class="pre">Value</span></tt>
+argument; we could have just passed <tt class="docutils literal"><span class="pre">node_iter</span></tt>'s <tt class="docutils literal"><span class="pre">Value</span></tt>
+along to <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>, and that'd even be shorter!  Most
+iterator class templates built with <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> are
 parameterized on another iterator type, rather than on its
-<tt class="literal"><span class="pre">value_type</span></tt>.  For example, <tt class="literal"><span class="pre">boost::reverse_iterator</span></tt> takes an
+<tt class="docutils literal"><span class="pre">value_type</span></tt>.  For example, <tt class="docutils literal"><span class="pre">boost::reverse_iterator</span></tt> takes an
 iterator type argument and reverses its direction of traversal,
 since the original iterator and the reversed one have all the same
-associated types, <tt class="literal"><span class="pre">iterator_adaptor</span></tt>'s delegation of default
-types to its <tt class="literal"><span class="pre">Base</span></tt> saves the implementor of
-<tt class="literal"><span class="pre">boost::reverse_iterator</span></tt> from writing</p>
+associated types, <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>'s delegation of default
+types to its <tt class="docutils literal"><span class="pre">Base</span></tt> saves the implementor of
+<tt class="docutils literal"><span class="pre">boost::reverse_iterator</span></tt> from writing:</p>
 <pre class="literal-block">
 std::iterator_traits&lt;Iterator&gt;::<em>some-associated-type</em>
 </pre>
 <p>at least four times.</p>
 <p>We urge you to review the documentation and implementations of
-<a class="reference" href="reverse_iterator.html"><tt class="literal"><span class="pre">reverse_iterator</span></tt></a> and the other Boost <a class="reference" href="index.html#specialized-adaptors">specialized iterator
+<a class="reference" href="reverse_iterator.html"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt></a> and the other Boost <a class="reference" href="index.html#specialized-adaptors">specialized iterator
 adaptors</a> to get an idea of the sorts of things you can do with
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt>.  In particular, have a look at
-<a class="reference" href="transform_iterator.html"><tt class="literal"><span class="pre">transform_iterator</span></tt></a>, which is perhaps the most straightforward
-adaptor, and also <a class="reference" href="counting_iterator.html"><tt class="literal"><span class="pre">counting_iterator</span></tt></a>, which demonstrates that
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt>'s <tt class="literal"><span class="pre">Base</span></tt> type needn't be an iterator.</p>
+<tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>.  In particular, have a look at
+<a class="reference" href="transform_iterator.html"><tt class="docutils literal"><span class="pre">transform_iterator</span></tt></a>, which is perhaps the most straightforward
+adaptor, and also <a class="reference" href="counting_iterator.html"><tt class="docutils literal"><span class="pre">counting_iterator</span></tt></a>, which demonstrates that
+<tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt>'s <tt class="docutils literal"><span class="pre">Base</span></tt> type needn't be an iterator.</p>
 </div>
 </div>
+<hr class="docutils footer" />
+<div class="footer">
+<a class="reference" href="iterator_adaptor.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
 </body>
 </html>

doc/iterator_adaptor.rst

@@ -8,7 +8,7 @@
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
 :date: $Date$
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu

doc/iterator_adaptor_abstract.rst

@@ -1,8 +1,7 @@
 .. Version 1.1 of this ReStructuredText document corresponds to
    n1530_, the paper accepted by the LWG.
 
-.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All
-   rights reserved
+.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 Each specialization of the ``iterator_adaptor`` class template is derived from
 a specialization of ``iterator_facade``. The core interface functions

doc/iterator_adaptor_body.rst

@@ -1,8 +1,7 @@
 .. Version 1.2 of this ReStructuredText document corresponds to
    n1530_, the paper accepted by the LWG for TR1.
 
-.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All
-   rights reserved
+.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 The ``iterator_adaptor`` class template adapts some ``Base`` [#base]_
 type to create a new iterator.  Instantiations of ``iterator_adaptor``
@@ -18,11 +17,12 @@ instance of the ``Base`` type, which it stores as a member.
 
 The user of ``iterator_adaptor`` creates a class derived from an
 instantiation of ``iterator_adaptor`` and then selectively
-redefines some of the core member functions described in the table
-above. The ``Base`` type need not meet the full requirements for an
-iterator. It need only support the operations used by the core
-interface functions of ``iterator_adaptor`` that have not been
-redefined in the user's derived class.
+redefines some of the core member functions described in the
+``iterator_facade`` core requirements table. The ``Base`` type need
+not meet the full requirements for an iterator; it need only
+support the operations used by the core interface functions of
+``iterator_adaptor`` that have not been redefined in the user's
+derived class.
 
 Several of the template parameters of ``iterator_adaptor`` default
 to ``use_default``. This allows the

doc/iterator_adaptor_ref.html

@@ -0,0 +1,234 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title></title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<div class="document">
+<!-- Version 1.4 of this ReStructuredText document corresponds to
+n1530_, the paper accepted by the LWG for TR1. -->
+<!-- Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.  -->
+<pre class="literal-block">
+template &lt;
+    class Derived
+  , class Base
+  , class Value               = use_default
+  , class CategoryOrTraversal = use_default
+  , class Reference           = use_default
+  , class Difference = use_default
+&gt;
+class iterator_adaptor 
+  : public iterator_facade&lt;Derived, <em>V'</em>, <em>C'</em>, <em>R'</em>, <em>D'</em>&gt; // see <a class="reference" href="#base-parameters">details</a>
+{
+    friend class iterator_core_access;
+ public:
+    iterator_adaptor();
+    explicit iterator_adaptor(Base iter);
+    Base const&amp; base() const;
+ protected:
+    typedef iterator_adaptor iterator_adaptor_;
+    Base const&amp; base_reference() const;
+    Base&amp; base_reference();
+ private: // Core iterator interface for iterator_facade.  
+    typename iterator_adaptor::reference dereference() const;
+
+    template &lt;
+    class OtherDerived, class OtherIterator, class V, class C, class R, class D
+    &gt;   
+    bool equal(iterator_adaptor&lt;OtherDerived, OtherIterator, V, C, R, D&gt; const&amp; x) const;
+
+    void advance(typename iterator_adaptor::difference_type n);
+    void increment();
+    void decrement();
+
+    template &lt;
+        class OtherDerived, class OtherIterator, class V, class C, class R, class D
+    &gt;   
+    typename iterator_adaptor::difference_type distance_to(
+        iterator_adaptor&lt;OtherDerived, OtherIterator, V, C, R, D&gt; const&amp; y) const;
+
+ private:
+    Base m_iterator; // exposition only
+};
+</pre>
+<a class="target" id="requirements" name="requirements"></a><div class="section" id="iterator-adaptor-requirements">
+<h1><a name="iterator-adaptor-requirements"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> requirements</a></h1>
+<p><tt class="literal"><span class="pre">static_cast&lt;Derived*&gt;(iterator_adaptor*)</span></tt> shall be well-formed.
+The <tt class="literal"><span class="pre">Base</span></tt> argument shall be Assignable and Copy Constructible.</p>
+<a class="target" id="base-parameters" name="base-parameters"></a></div>
+<div class="section" id="iterator-adaptor-base-class-parameters">
+<h1><a name="iterator-adaptor-base-class-parameters"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> base class parameters</a></h1>
+<p>The <em>V'</em>, <em>C'</em>, <em>R'</em>, and <em>D'</em> parameters of the <tt class="literal"><span class="pre">iterator_facade</span></tt>
+used as a base class in the summary of <tt class="literal"><span class="pre">iterator_adaptor</span></tt>
+above are defined as follows:</p>
+<pre class="literal-block">
+<em>V'</em> = if (Value is use_default)
+          return iterator_traits&lt;Base&gt;::value_type
+      else
+          return Value
+
+<em>C'</em> = if (CategoryOrTraversal is use_default)
+          return iterator_traversal&lt;Base&gt;::type
+      else
+          return CategoryOrTraversal
+
+<em>R'</em> = if (Reference is use_default)
+          if (Value is use_default)
+              return iterator_traits&lt;Base&gt;::reference
+          else
+              return Value&amp;
+      else
+          return Reference
+
+<em>D'</em> = if (Difference is use_default)
+          return iterator_traits&lt;Base&gt;::difference_type
+      else
+          return Difference
+</pre>
+<!-- ``iterator_adaptor`` models
+- - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+In order for ``Derived`` to model the iterator concepts corresponding
+to ``iterator_traits<Derived>::iterator_category``, the expressions
+involving ``m_iterator`` in the specifications of those private member
+functions of ``iterator_adaptor`` that may be called by
+``iterator_facade<Derived, V, C, R, D>`` in evaluating any valid
+expression involving ``Derived`` in those concepts' requirements. -->
+<!-- The above is confusing and needs a rewrite. -JGS -->
+<!-- That's why it's removed.  We're embracing inheritance, remember? -->
+</div>
+<div class="section" id="iterator-adaptor-public-operations">
+<h1><a name="iterator-adaptor-public-operations"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> public operations</a></h1>
+<p><tt class="literal"><span class="pre">iterator_adaptor();</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body">The <tt class="literal"><span class="pre">Base</span></tt> type must be Default Constructible.</td>
+</tr>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> with 
+<tt class="literal"><span class="pre">m_iterator</span></tt> default constructed.</td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">explicit</span> <span class="pre">iterator_adaptor(Base</span> <span class="pre">iter);</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> with
+<tt class="literal"><span class="pre">m_iterator</span></tt> copy constructed from <tt class="literal"><span class="pre">iter</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">Base</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span></tt></td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="iterator-adaptor-protected-member-functions">
+<h1><a name="iterator-adaptor-protected-member-functions"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> protected member functions</a></h1>
+<p><tt class="literal"><span class="pre">Base</span> <span class="pre">const&amp;</span> <span class="pre">base_reference()</span> <span class="pre">const;</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A const reference to <tt class="literal"><span class="pre">m_iterator</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">Base&amp;</span> <span class="pre">base_reference();</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A non-const reference to <tt class="literal"><span class="pre">m_iterator</span></tt>.</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="section" id="iterator-adaptor-private-member-functions">
+<h1><a name="iterator-adaptor-private-member-functions"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> private member functions</a></h1>
+<p><tt class="literal"><span class="pre">typename</span> <span class="pre">iterator_adaptor::reference</span> <span class="pre">dereference()</span> <span class="pre">const;</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*m_iterator</span></tt></td>
+</tr>
+</tbody>
+</table>
+<pre class="literal-block">
+template &lt;
+class OtherDerived, class OtherIterator, class V, class C, class R, class D
+&gt;   
+bool equal(iterator_adaptor&lt;OtherDerived, OtherIterator, V, C, R, D&gt; const&amp; x) const;
+</pre>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span> <span class="pre">==</span> <span class="pre">x.base()</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">void</span> <span class="pre">advance(typename</span> <span class="pre">iterator_adaptor::difference_type</span> <span class="pre">n);</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span> <span class="pre">+=</span> <span class="pre">n;</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">void</span> <span class="pre">increment();</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">++m_iterator;</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p><tt class="literal"><span class="pre">void</span> <span class="pre">decrement();</span></tt></p>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">--m_iterator;</span></tt></td>
+</tr>
+</tbody>
+</table>
+<pre class="literal-block">
+template &lt;
+    class OtherDerived, class OtherIterator, class V, class C, class R, class D
+&gt;   
+typename iterator_adaptor::difference_type distance_to(
+    iterator_adaptor&lt;OtherDerived, OtherIterator, V, C, R, D&gt; const&amp; y) const;
+</pre>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">y.base()</span> <span class="pre">-</span> <span class="pre">m_iterator</span></tt></td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="iterator_adaptor_ref.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/iterator_adaptor_ref.rst

@@ -1,8 +1,7 @@
 .. Version 1.4 of this ReStructuredText document corresponds to
    n1530_, the paper accepted by the LWG for TR1.
 
-.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All
-   rights reserved.
+.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. parsed-literal::
   
@@ -20,9 +19,11 @@
       friend class iterator_core_access;
    public:
       iterator_adaptor();
-      explicit iterator_adaptor(Base iter);
+      explicit iterator_adaptor(Base const& iter);
+      typedef Base base_type;
       Base const& base() const;
    protected:
+      typedef iterator_adaptor iterator_adaptor\_;
       Base const& base_reference() const;
       Base& base_reference();
    private: // Core iterator interface for iterator_facade.  
@@ -115,7 +116,7 @@ above are defined as follows:
     ``m_iterator`` default constructed.
 
 
-``explicit iterator_adaptor(Base iter);``
+``explicit iterator_adaptor(Base const& iter);``
 
 :Returns: An instance of ``iterator_adaptor`` with
     ``m_iterator`` copy constructed from ``iter``.

doc/iterator_adaptor_tutorial.rst

@@ -21,7 +21,7 @@ we're going to pick up right where it left off.
    words, the original iterator traverses a one-element array.
 
 You probably didn't think of it this way, but the ``node_base*``
-object which underlies ``node_iterator`` is itself an iterator,
+object that underlies ``node_iterator`` is itself an iterator,
 just like all other pointers.  If we examine that pointer closely
 from an iterator perspective, we can see that it has much in common
 with the ``node_iterator`` we're building.  First, they share most
@@ -30,9 +30,10 @@ of the same associated types (``value_type``, ``reference``,
 core functionality is the same: ``operator*`` and ``operator==`` on
 the ``node_iterator`` return the result of invoking the same
 operations on the underlying pointer, via the ``node_iterator``\ 's
-|dereference_and_equal|_). However, the ``operator++`` for
-``node_iterator`` behaves differently than for ``node_base*``
-since it follows the ``m_next`` pointer.
+|dereference_and_equal|_).  The only real behavioral difference
+between ``node_base*`` and ``node_iterator`` can be observed when
+they are incremented: ``node_iterator`` follows the
+``m_next`` pointer, while ``node_base*`` just applies an address offset.   
 
 .. |dereference_and_equal| replace:: ``dereference`` and ``equal`` member functions
 .. _dereference_and_equal: iterator_facade.html#implementing-the-core-operations
@@ -60,16 +61,12 @@ behaviors other than ``increment``.  The implementation of
    private:
       struct enabler {};  // a private type avoids misuse
 
-      typedef boost::iterator_adaptor<
-          node_iter<Value>, Value*, boost::use_default, boost::forward_traversal_tag
-      > super_t;
-
    public:
       node_iter()
-        : super_t(0) {}
+        : node_iter::iterator_adaptor_(0) {}
 
       explicit node_iter(Value* p)
-        : super_t(p) {}
+        : node_iter::iterator_adaptor_(p) {}
 
       template <class OtherValue>
       node_iter(
@@ -79,14 +76,21 @@ behaviors other than ``increment``.  The implementation of
             , enabler
           >::type = enabler()
       )
-        : super_t(other.base()) {}
+        : node_iter::iterator_adaptor_(other.base()) {}
 
    private:
       friend class boost::iterator_core_access;
       void increment() { this->base_reference() = this->base()->next(); }
   };
 
-You can see an example program which exercises this version of the
+Note the use of ``node_iter::iterator_adaptor_`` here: because
+``iterator_adaptor`` defines a nested ``iterator_adaptor_`` type
+that refers to itself, that gives us a convenient way to refer to
+the complicated base class type of ``node_iter<Value>``. [Note:
+this technique is known not to work with Borland C++ 5.6.4 and
+Metrowerks CodeWarrior versions prior to 9.0]
+
+You can see an example program that exercises this version of the
 node iterators `here`__.
 
 __ ../example/node_iterator3.cpp
@@ -102,7 +106,7 @@ iterator type argument and reverses its direction of traversal,
 since the original iterator and the reversed one have all the same
 associated types, ``iterator_adaptor``\ 's delegation of default
 types to its ``Base`` saves the implementor of
-``boost::reverse_iterator`` from writing
+``boost::reverse_iterator`` from writing:
 
 .. parsed-literal::
 

doc/iterator_archetypes.html

@@ -3,12 +3,12 @@
 <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.3.1: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.8: http://docutils.sourceforge.net/" />
 <title>Iterator Archetype</title>
 <meta name="author" content="David Abrahams, Jeremy Siek, Thomas Witt" />
 <meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab, Zephyr Associates, Inc." />
-<meta name="date" content="2004-01-13" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. All rights reserved" />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004." />
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
@@ -26,46 +26,50 @@
 <td><a class="first reference" href="http://www.boost-consulting.com">Boost Consulting</a>, Indiana University <a class="reference" href="http://www.osl.iu.edu">Open Systems
 Lab</a>, <a class="last reference" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2004-01-13</td></tr>
+<td>2004-11-01</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. All rights reserved</td></tr>
+<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004.</td></tr>
 </tbody>
 </table>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">abstract:</th><td class="field-body">iterator archetypes provide a means to check the compile time requirements of a generic component on its iterator arguments.</td>
+<tr class="field"><th class="field-name">abstract:</th><td class="field-body">The <tt class="docutils literal"><span class="pre">iterator_archetype</span></tt> class constructs a minimal implementation of
+one of the iterator access concepts and one of the iterator traversal concepts.
+This is used for doing a compile-time check to see if a the type requirements
+of a template are really enough to cover the implementation of the template.
+For further information see the documentation for the <a class="reference" href="../../concept_check/index.html"><tt class="docutils literal"><span class="pre">boost::concept_check</span></tt></a> library.</td>
 </tr>
 </tbody>
 </table>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
+<p class="topic-title first"><a name="table-of-contents">Table of Contents</a></p>
 <ul class="simple">
-<li><a class="reference" href="#reference" id="id3" name="id3">Reference</a><ul>
-<li><a class="reference" href="#iterator-archetype-synopsis" id="id4" name="id4"><tt class="literal"><span class="pre">iterator_archetype</span></tt> Synopsis</a></li>
-<li><a class="reference" href="#access-category-tags" id="id5" name="id5"><tt class="literal"><span class="pre">Access</span> <span class="pre">Category</span> <span class="pre">Tags</span></tt></a></li>
-<li><a class="reference" href="#iterator-archetype-requirements" id="id6" name="id6"><tt class="literal"><span class="pre">iterator_archetype</span></tt> Requirements</a></li>
-<li><a class="reference" href="#iterator-archetype-models" id="id7" name="id7"><tt class="literal"><span class="pre">iterator_archetype</span></tt> Models</a></li>
-<li><a class="reference" href="#traits" id="id8" name="id8"><tt class="literal"><span class="pre">Traits</span></tt></a></li>
+<li><a class="reference" href="#reference" id="id1" name="id1">Reference</a><ul>
+<li><a class="reference" href="#iterator-archetype-synopsis" id="id2" name="id2"><tt class="docutils literal"><span class="pre">iterator_archetype</span></tt> Synopsis</a></li>
+<li><a class="reference" href="#access-category-tags" id="id3" name="id3"><tt class="docutils literal"><span class="pre">Access</span> <span class="pre">Category</span> <span class="pre">Tags</span></tt></a></li>
+<li><a class="reference" href="#iterator-archetype-requirements" id="id4" name="id4"><tt class="docutils literal"><span class="pre">iterator_archetype</span></tt> Requirements</a></li>
+<li><a class="reference" href="#iterator-archetype-models" id="id5" name="id5"><tt class="docutils literal"><span class="pre">iterator_archetype</span></tt> Models</a></li>
+<li><a class="reference" href="#traits" id="id6" name="id6"><tt class="docutils literal"><span class="pre">Traits</span></tt></a></li>
 </ul>
 </li>
 </ul>
 </div>
 <div class="section" id="reference">
-<h1><a class="toc-backref" href="#id3" name="reference">Reference</a></h1>
+<h1><a class="toc-backref" href="#id1" name="reference">Reference</a></h1>
 <div class="section" id="iterator-archetype-synopsis">
-<h2><a class="toc-backref" href="#id4" name="iterator-archetype-synopsis"><tt class="literal"><span class="pre">iterator_archetype</span></tt> Synopsis</a></h2>
+<h2><a class="toc-backref" href="#id2" name="iterator-archetype-synopsis"><tt class="docutils literal"><span class="pre">iterator_archetype</span></tt> Synopsis</a></h2>
 <pre class="literal-block">
 namespace iterator_archetypes
 {
     // Access categories
 
-    typedef /<em>implementation  defined</em>/ readable_iterator_t;
-    typedef /<em>implementation  defined</em>/ writable_iterator_t;
-    typedef /<em>implementation  defined</em>/ readable_writable_iterator_t;
-    typedef /<em>implementation  defined</em>/ readable_lvalue_iterator_t;
-    typedef /<em>implementation  defined</em>/ writable_lvalue_iterator_t;
+    typedef /*implementation  defined*/ readable_iterator_t;
+    typedef /*implementation  defined*/ writable_iterator_t;
+    typedef /*implementation  defined*/ readable_writable_iterator_t;
+    typedef /*implementation  defined*/ readable_lvalue_iterator_t;
+    typedef /*implementation  defined*/ writable_lvalue_iterator_t;
 
 }
 
@@ -76,19 +80,16 @@ template &lt;
 &gt;
 class iterator_archetype
 {
-    typedef /* see below <em>/ value_type;
-    typedef /</em> see below <em>/ reference;
-    typedef /</em> see below <em>/ pointer;
-    typedef /</em> see below <em>/ difference_type;
-    typedef /</em> see below <a href="#id1" name="id2"><span class="problematic" id="id2">*</span></a>/ iterator_category;
+    typedef /* see below */ value_type;
+    typedef /* see below */ reference;
+    typedef /* see below */ pointer;
+    typedef /* see below */ difference_type;
+    typedef /* see below */ iterator_category;
 };
 </pre>
-<div class="system-message" id="id1">
-<p class="system-message-title">System Message: <a name="id1">WARNING/2</a> (<tt>iterator_archetypes.rst</tt>, line 26); <em><a href="#id2">backlink</a></em></p>
-Inline emphasis start-string without end-string.</div>
 </div>
 <div class="section" id="access-category-tags">
-<h2><a class="toc-backref" href="#id5" name="access-category-tags"><tt class="literal"><span class="pre">Access</span> <span class="pre">Category</span> <span class="pre">Tags</span></tt></a></h2>
+<h2><a class="toc-backref" href="#id3" name="access-category-tags"><tt class="docutils literal"><span class="pre">Access</span> <span class="pre">Category</span> <span class="pre">Tags</span></tt></a></h2>
 <p>The access category types provided correspond to the following
 standard iterator access concept combinations:</p>
 <pre class="literal-block">
@@ -114,22 +115,22 @@ writeable_lvalue_iterator_t :=
 </pre>
 </div>
 <div class="section" id="iterator-archetype-requirements">
-<h2><a class="toc-backref" href="#id6" name="iterator-archetype-requirements"><tt class="literal"><span class="pre">iterator_archetype</span></tt> Requirements</a></h2>
-<p>The <tt class="literal"><span class="pre">AccessCategory</span></tt> argument must be one of the predefined access
-category tags. The <tt class="literal"><span class="pre">TraversalCategory</span></tt> must be one of the standard
-traversal tags. The <tt class="literal"><span class="pre">Value</span></tt> type must satisfy the requirements of
-the iterator concept specified by <tt class="literal"><span class="pre">AccessCategory</span></tt> and
-<tt class="literal"><span class="pre">TraversalCategory</span></tt> as implied by the nested traits types.</p>
+<h2><a class="toc-backref" href="#id4" name="iterator-archetype-requirements"><tt class="docutils literal"><span class="pre">iterator_archetype</span></tt> Requirements</a></h2>
+<p>The <tt class="docutils literal"><span class="pre">AccessCategory</span></tt> argument must be one of the predefined access
+category tags. The <tt class="docutils literal"><span class="pre">TraversalCategory</span></tt> must be one of the standard
+traversal tags. The <tt class="docutils literal"><span class="pre">Value</span></tt> type must satisfy the requirements of
+the iterator concept specified by <tt class="docutils literal"><span class="pre">AccessCategory</span></tt> and
+<tt class="docutils literal"><span class="pre">TraversalCategory</span></tt> as implied by the nested traits types.</p>
 </div>
 <div class="section" id="iterator-archetype-models">
-<h2><a class="toc-backref" href="#id7" name="iterator-archetype-models"><tt class="literal"><span class="pre">iterator_archetype</span></tt> Models</a></h2>
-<p><tt class="literal"><span class="pre">iterator_archetype</span></tt> models the iterator concepts specified by the
-<tt class="literal"><span class="pre">AccessCategory</span></tt> and <tt class="literal"><span class="pre">TraversalCategory</span></tt>
-arguments. <tt class="literal"><span class="pre">iterator_archetype</span></tt> does not model any other access
+<h2><a class="toc-backref" href="#id5" name="iterator-archetype-models"><tt class="docutils literal"><span class="pre">iterator_archetype</span></tt> Models</a></h2>
+<p><tt class="docutils literal"><span class="pre">iterator_archetype</span></tt> models the iterator concepts specified by the
+<tt class="docutils literal"><span class="pre">AccessCategory</span></tt> and <tt class="docutils literal"><span class="pre">TraversalCategory</span></tt>
+arguments. <tt class="docutils literal"><span class="pre">iterator_archetype</span></tt> does not model any other access
 concepts or any more derived traversal concepts.</p>
 </div>
 <div class="section" id="traits">
-<h2><a class="toc-backref" href="#id8" name="traits"><tt class="literal"><span class="pre">Traits</span></tt></a></h2>
+<h2><a class="toc-backref" href="#id6" name="traits"><tt class="docutils literal"><span class="pre">Traits</span></tt></a></h2>
 <p>The nested trait types are defined as follows:</p>
 <pre class="literal-block">
 if (AccessCategory == readable_iterator_t)
@@ -210,10 +211,9 @@ iterator_category :=
 </div>
 </div>
 </div>
-<hr class="footer" />
+<hr class="docutils footer" />
 <div class="footer">
 <a class="reference" href="iterator_archetypes.rst">View document source</a>.
-Generated on: 2004-01-16 18:30 UTC.
 Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
 </div>
 </body>

doc/iterator_archetypes.rst

@@ -7,13 +7,21 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_, `Zephyr Associates, Inc.`_
 :date: $Date$
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. All rights reserved
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu
 .. _`Zephyr Associates, Inc.`: http://www.styleadvisor.com
 
-:abstract: iterator archetypes provide a means to check the compile time requirements of a generic component on its iterator arguments.
+:abstract: The ``iterator_archetype`` class constructs a minimal implementation of
+  one of the iterator access concepts and one of the iterator traversal concepts.
+  This is used for doing a compile-time check to see if a the type requirements
+  of a template are really enough to cover the implementation of the template.
+  For further information see the documentation for the |concepts|_ library.
+
+.. |concepts| replace:: ``boost::concept_check``
+.. _concepts: ../../concept_check/index.html
+
 
 .. contents:: Table of Contents
 
@@ -23,7 +31,7 @@ Reference
 ``iterator_archetype`` Synopsis
 ...............................
 
-.. parsed-literal::
+::
 
     namespace iterator_archetypes
     {
@@ -57,7 +65,7 @@ Reference
 The access category types provided correspond to the following
 standard iterator access concept combinations:
 
-.. parsed-literal::
+::
 
     readable_iterator_t :=
   
@@ -101,7 +109,7 @@ concepts or any more derived traversal concepts.
 
 The nested trait types are defined as follows:
 
-.. parsed-literal::
+::
 
    if (AccessCategory == readable_iterator_t)
      
@@ -178,4 +186,4 @@ The nested trait types are defined as follows:
 
         2. X is convertible to TraversalCategory
 
-        
+        

doc/iterator_concepts.html

@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.8: http://docutils.sourceforge.net/" />
+<title>Iterator Concepts</title>
+<meta name="author" content="David Abrahams, Jeremy Siek, Thomas Witt" />
+<meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab, Zephyr Associates, Inc." />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004." />
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<div class="document" id="iterator-concepts">
+<h1 class="title">Iterator Concepts</h1>
+<table class="docinfo" frame="void" rules="none">
+<col class="docinfo-name" />
+<col class="docinfo-content" />
+<tbody valign="top">
+<tr><th class="docinfo-name">Author:</th>
+<td>David Abrahams, Jeremy Siek, Thomas Witt</td></tr>
+<tr><th class="docinfo-name">Contact:</th>
+<td><a class="first reference" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a>, <a class="reference" href="mailto:jsiek&#64;osl.iu.edu">jsiek&#64;osl.iu.edu</a>, <a class="last reference" href="mailto:witt&#64;styleadvisor.com">witt&#64;styleadvisor.com</a></td></tr>
+<tr><th class="docinfo-name">Organization:</th>
+<td><a class="first reference" href="http://www.boost-consulting.com">Boost Consulting</a>, Indiana University <a class="reference" href="http://www.osl.iu.edu">Open Systems
+Lab</a>, <a class="last reference" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></td></tr>
+<tr><th class="docinfo-name">Date:</th>
+<td>2004-11-01</td></tr>
+<tr><th class="docinfo-name">Copyright:</th>
+<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004.</td></tr>
+</tbody>
+</table>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">abstract:</th><td class="field-body">The iterator concept checking classes provide a mechanism for
+a template to report better error messages when a user instantiates
+the template with a type that does not meet the requirements of
+the template.</td>
+</tr>
+</tbody>
+</table>
+<p>For an introduction to using concept checking classes, see
+the documentation for the <a class="reference" href="../../concept_check/index.html"><tt class="docutils literal"><span class="pre">boost::concept_check</span></tt></a> library.</p>
+<div class="section" id="reference">
+<h1><a name="reference">Reference</a></h1>
+<div class="section" id="iterator-access-concepts">
+<h2><a name="iterator-access-concepts">Iterator Access Concepts</a></h2>
+<ul class="simple">
+<li><a class="reference" href="ReadableIterator.html"><em>Readable Iterator</em></a></li>
+<li><a class="reference" href="WritableIterator.html"><em>Writable Iterator</em></a></li>
+<li><a class="reference" href="SwappableIterator.html"><em>Swappable Iterator</em></a></li>
+<li><a class="reference" href="LvalueIterator.html"><em>Lvalue Iterator</em></a></li>
+</ul>
+</div>
+<div class="section" id="iterator-traversal-concepts">
+<h2><a name="iterator-traversal-concepts">Iterator Traversal Concepts</a></h2>
+<ul class="simple">
+<li><a class="reference" href="IncrementableIterator.html"><em>Incrementable Iterator</em></a></li>
+<li><a class="reference" href="SinglePassIterator.html"><em>Single Pass Iterator</em></a></li>
+<li><a class="reference" href="ForwardTraversal.html"><em>Forward Traversal</em></a></li>
+<li><a class="reference" href="BidirectionalTraversal.html"><em>Bidirectional Traversal</em></a></li>
+<li><a class="reference" href="RandomAccessTraversal.html"><em>Random Access Traversal</em></a></li>
+</ul>
+</div>
+<div class="section" id="iterator-concepts-hpp-synopsis">
+<h2><a name="iterator-concepts-hpp-synopsis"><tt class="docutils literal"><span class="pre">iterator_concepts.hpp</span></tt> Synopsis</a></h2>
+<pre class="literal-block">
+namespace boost_concepts {
+
+    // Iterator Access Concepts
+
+    template &lt;typename Iterator&gt;
+    class ReadableIteratorConcept;
+
+    template &lt;
+        typename Iterator
+      , typename ValueType = std::iterator_traits&lt;Iterator&gt;::value_type
+    &gt;
+    class WritableIteratorConcept;
+
+    template &lt;typename Iterator&gt;
+    class SwappableIteratorConcept;
+
+    template &lt;typename Iterator&gt;
+    class LvalueIteratorConcept;
+
+    // Iterator Traversal Concepts
+
+    template &lt;typename Iterator&gt;
+    class IncrementableIteratorConcept;
+
+    template &lt;typename Iterator&gt;
+    class SinglePassIteratorConcept;
+
+    template &lt;typename Iterator&gt;
+    class ForwardTraversalConcept;
+
+    template &lt;typename Iterator&gt;
+    class BidirectionalTraversalConcept;
+
+    template &lt;typename Iterator&gt;
+    class RandomAccessTraversalConcept;
+
+    // Interoperability
+
+    template &lt;typename Iterator, typename ConstIterator&gt;
+    class InteroperableIteratorConcept;
+
+}
+</pre>
+</div>
+</div>
+</div>
+<hr class="docutils footer" />
+<div class="footer">
+<a class="reference" href="iterator_concepts.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/iterator_concepts.rst

@@ -0,0 +1,128 @@
+
+
+++++++++++++++++++
+ Iterator Concepts
+++++++++++++++++++
+
+:Author: David Abrahams, Jeremy Siek, Thomas Witt
+:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
+:organization: `Boost Consulting`_, Indiana University `Open Systems
+               Lab`_, `Zephyr Associates, Inc.`_
+:date: $Date$
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. 
+
+.. _`Boost Consulting`: http://www.boost-consulting.com
+.. _`Open Systems Lab`: http://www.osl.iu.edu
+.. _`Zephyr Associates, Inc.`: http://www.styleadvisor.com
+
+:abstract:  The iterator concept checking classes provide a mechanism for
+  a template to report better error messages when a user instantiates
+  the template with a type that does not meet the requirements of
+  the template.
+
+
+For an introduction to using concept checking classes, see
+the documentation for the |concepts|_ library.
+
+.. |concepts| replace:: ``boost::concept_check``
+.. _concepts: ../../concept_check/index.html
+
+
+Reference
+=========
+
+Iterator Access Concepts
+........................
+
+* |Readable|_ 
+* |Writable|_ 
+* |Swappable|_ 
+* |Lvalue|_ 
+
+.. |Readable| replace:: *Readable Iterator*
+.. _Readable: ReadableIterator.html
+
+.. |Writable| replace:: *Writable Iterator*
+.. _Writable: WritableIterator.html
+
+.. |Swappable| replace:: *Swappable Iterator*
+.. _Swappable: SwappableIterator.html
+
+.. |Lvalue| replace:: *Lvalue Iterator*
+.. _Lvalue: LvalueIterator.html
+
+
+Iterator Traversal Concepts
+...........................
+
+* |Incrementable|_
+* |SinglePass|_
+* |Forward|_
+* |Bidir|_
+* |Random|_
+
+
+.. |Incrementable| replace:: *Incrementable Iterator*
+.. _Incrementable: IncrementableIterator.html
+
+.. |SinglePass| replace:: *Single Pass Iterator*
+.. _SinglePass: SinglePassIterator.html
+
+.. |Forward| replace:: *Forward Traversal*
+.. _Forward: ForwardTraversal.html
+
+.. |Bidir| replace:: *Bidirectional Traversal*
+.. _Bidir: BidirectionalTraversal.html
+
+.. |Random| replace:: *Random Access Traversal*
+.. _Random: RandomAccessTraversal.html
+
+
+
+``iterator_concepts.hpp`` Synopsis
+..................................
+
+::
+
+    namespace boost_concepts {
+
+        // Iterator Access Concepts
+
+        template <typename Iterator>
+        class ReadableIteratorConcept;
+
+        template <
+            typename Iterator
+          , typename ValueType = std::iterator_traits<Iterator>::value_type
+        >
+        class WritableIteratorConcept;
+
+        template <typename Iterator>
+        class SwappableIteratorConcept;
+
+        template <typename Iterator>
+        class LvalueIteratorConcept;
+
+        // Iterator Traversal Concepts
+
+        template <typename Iterator>
+        class IncrementableIteratorConcept;
+
+        template <typename Iterator>
+        class SinglePassIteratorConcept;
+
+        template <typename Iterator>
+        class ForwardTraversalConcept;
+
+        template <typename Iterator>
+        class BidirectionalTraversalConcept;
+
+        template <typename Iterator>
+        class RandomAccessTraversalConcept;
+
+        // Interoperability
+
+        template <typename Iterator, typename ConstIterator>
+        class InteroperableIteratorConcept;
+
+    }

doc/iterator_facade.rst

@@ -8,7 +8,7 @@
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
 :date: $Date$
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu

doc/iterator_facade_body.rst

@@ -1,8 +1,7 @@
 .. Version 1.1 of this ReStructuredText document corresponds to
    n1530_, the paper accepted by the LWG for TR1.
 
-.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All
-   rights reserved
+.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 
 While the iterator interface is rich, there is a core subset of the

doc/iterator_facade_ref.rst

@@ -1,8 +1,7 @@
 .. Version 1.3 of this ReStructuredText document corresponds to
    n1530_, the paper accepted by the LWG for TR1.
 
-.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All
-   rights reserved
+.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 
 .. parsed-literal::
@@ -15,7 +14,7 @@
     , class Difference = ptrdiff_t
   >
   class iterator_facade {
-  public:
+   public:
       typedef remove_const<Value>::type value_type;
       typedef Reference reference;
       typedef Value\* pointer;
@@ -32,6 +31,8 @@
       Derived& operator+=(difference_type n);
       Derived& operator-=(difference_type n);
       Derived operator-(difference_type n) const;
+   protected:
+      typedef iterator_facade iterator_facade\_;
   };
 
   // Comparison operators
@@ -311,8 +312,14 @@ __ `operator arrow`_
   operator ==(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
-:Returns: if ``is_convertible<Dr2,Dr1>::value``, then
-  ``lhs.equal(rhs)``.  Otherwise, ``rhs.equal(lhs)``.
+:Returns: 
+  if ``is_convertible<Dr2,Dr1>::value``
+
+  then 
+    ``((Dr1 const&)lhs).equal((Dr2 const&)rhs)``.
+
+  Otherwise, 
+    ``((Dr2 const&)rhs).equal((Dr1 const&)lhs)``.
 
 ::
 
@@ -322,8 +329,14 @@ __ `operator arrow`_
   operator !=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
-:Returns: if ``is_convertible<Dr2,Dr1>::value``, then
-  ``!lhs.equal(rhs)``.  Otherwise, ``!rhs.equal(lhs)``.
+:Returns: 
+  if ``is_convertible<Dr2,Dr1>::value``
+
+  then 
+    ``!((Dr1 const&)lhs).equal((Dr2 const&)rhs)``.
+
+  Otherwise, 
+    ``!((Dr2 const&)rhs).equal((Dr1 const&)lhs)``.
 
 ::
 
@@ -333,9 +346,14 @@ __ `operator arrow`_
   operator <(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
-:Returns: if ``is_convertible<Dr2,Dr1>::value``, then
-  ``lhs.distance_to(rhs) < 0``. Otherwise, ``rhs.distance_to(lhs) >
-  0``.
+:Returns: 
+  if ``is_convertible<Dr2,Dr1>::value``
+
+  then 
+    ``((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) < 0``.
+
+  Otherwise, 
+    ``((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) > 0``.
 
 ::
 
@@ -345,9 +363,14 @@ __ `operator arrow`_
   operator <=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
-:Returns: if ``is_convertible<Dr2,Dr1>::value``, then
-  ``lhs.distance_to(rhs) <= 0``. Otherwise, ``rhs.distance_to(lhs)
-  >= 0``.
+:Returns: 
+  if ``is_convertible<Dr2,Dr1>::value``
+
+  then 
+    ``((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) <= 0``.
+
+  Otherwise, 
+    ``((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) >= 0``.
 
 ::
 
@@ -357,9 +380,14 @@ __ `operator arrow`_
   operator >(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
-:Returns: if ``is_convertible<Dr2,Dr1>::value``, then
-  ``lhs.distance_to(rhs) > 0``. Otherwise,
-  ``rhs.distance_to(lhs) < 0``.
+:Returns: 
+  if ``is_convertible<Dr2,Dr1>::value``
+
+  then 
+    ``((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) > 0``.
+
+  Otherwise, 
+    ``((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) < 0``.
 
 
 ::
@@ -370,9 +398,14 @@ __ `operator arrow`_
   operator >=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
               iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
-:Returns: if ``is_convertible<Dr2,Dr1>::value``, then
-  ``lhs.distance_to(rhs) >= 0``. Otherwise,
-  ``rhs.distance_to(lhs) <= 0``.
+:Returns: 
+  if ``is_convertible<Dr2,Dr1>::value``
+
+  then 
+    ``((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) >= 0``.
+
+  Otherwise, 
+    ``((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) <= 0``.
 
 .. _minus:
 
@@ -380,15 +413,25 @@ __ `operator arrow`_
 
   template <class Dr1, class V1, class TC1, class R1, class D1,
             class Dr2, class V2, class TC2, class R2, class D2>
-  typename enable_if_interoperable<Dr1,Dr2,difference_type>::type
+  typename enable_if_interoperable<Dr1,Dr2,difference>::type
   operator -(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
 
-:Return Type: if ``is_convertible<Dr2,Dr1>::value``, then ``difference_type`` shall be
-  ``iterator_traits<Dr1>::difference_type``.  Otherwise,
-  ``difference_type`` shall be
-  ``iterator_traits<Dr2>::difference_type``.
+:Return Type: 
+  if ``is_convertible<Dr2,Dr1>::value``
 
-:Returns: if ``is_convertible<Dr2,Dr1>::value``, then
-  ``-lhs.distance_to(rhs)``. Otherwise,
-  ``rhs.distance_to(lhs)``.
+   then 
+    ``difference`` shall be
+    ``iterator_traits<Dr1>::difference_type``.
+
+   Otherwise 
+    ``difference`` shall be ``iterator_traits<Dr2>::difference_type``
+
+:Returns: 
+  if ``is_convertible<Dr2,Dr1>::value``
+
+  then 
+    ``-((Dr1 const&)lhs).distance_to((Dr2 const&)rhs)``.
+
+  Otherwise, 
+    ``((Dr2 const&)rhs).distance_to((Dr1 const&)lhs)``.

doc/iterator_facade_tutorial.rst

@@ -483,6 +483,10 @@ appropriate::
 
     ...
 
+  private: 
+    struct enabler {};
+
+  public:
     template <class OtherValue>
     node_iter(
         node_iter<OtherValue> const& other

doc/iterator_traits.html

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.8: http://docutils.sourceforge.net/" />
+<title>Iterator Traits</title>
+<meta name="author" content="David Abrahams" />
+<meta name="organization" content="Boost Consulting" />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright David Abrahams 2004." />
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<div class="document" id="iterator-traits">
+<h1 class="title">Iterator Traits</h1>
+<table class="docinfo" frame="void" rules="none">
+<col class="docinfo-name" />
+<col class="docinfo-content" />
+<tbody valign="top">
+<tr><th class="docinfo-name">Author:</th>
+<td>David Abrahams</td></tr>
+<tr><th class="docinfo-name">Contact:</th>
+<td><a class="first last reference" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a></td></tr>
+<tr><th class="docinfo-name">Organization:</th>
+<td><a class="first last reference" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
+<tr><th class="docinfo-name">Date:</th>
+<td>2004-11-01</td></tr>
+<tr><th class="docinfo-name">Copyright:</th>
+<td>Copyright David Abrahams 2004.</td></tr>
+</tbody>
+</table>
+<table class="docutils field-list" frame="void" rules="none">
+<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
+the ability to access an iterator's associated types using
+MPL-compatible <a class="reference" href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a>.</td>
+</tr>
+</tbody>
+</table>
+<div class="section" id="overview">
+<h1><a name="overview">Overview</a></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,
+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>
+provides access to these types using a standard <a class="reference" href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a>.</p>
+</div>
+<div class="section" id="summary">
+<h1><a name="summary">Summary</a></h1>
+<p>Header <tt class="docutils literal"><span class="pre">&lt;boost/iterator/iterator_traits.hpp&gt;</span></tt>:</p>
+<pre class="literal-block">
+template &lt;class Iterator&gt;
+struct iterator_value
+{
+    typedef typename 
+      std::iterator_traits&lt;Iterator&gt;::value_type 
+    type;
+};
+
+template &lt;class Iterator&gt;
+struct iterator_reference
+{
+    typedef typename 
+      std::iterator_traits&lt;Iterator&gt;::reference
+    type;
+};
+
+
+template &lt;class Iterator&gt;
+struct iterator_pointer
+{
+    typedef typename 
+      std::iterator_traits&lt;Iterator&gt;::pointer 
+    type;
+};
+
+template &lt;class Iterator&gt;
+struct iterator_difference
+{
+    typedef typename
+      detail::iterator_traits&lt;Iterator&gt;::difference_type
+    type;
+};
+
+template &lt;class Iterator&gt;
+struct iterator_category
+{
+    typedef typename
+      detail::iterator_traits&lt;Iterator&gt;::iterator_category
+    type;
+};
+</pre>
+</div>
+<div class="section" id="broken-compiler-notes">
+<h1><a name="broken-compiler-notes">Broken Compiler Notes</a></h1>
+<p>Because of workarounds in Boost, you may find that these
+<a class="reference" href="../../mpl/doc/refmanual/metafunction.html">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" href="../../../doc/html/boost_typetraits/category.html#boost_typetraits.transform">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>
+<hr class="docutils footer" />
+<div class="footer">
+<a class="reference" href="iterator_traits.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/iterator_traits.rst

@@ -0,0 +1,94 @@
++++++++++++++++++
+ Iterator Traits
++++++++++++++++++
+
+:Author: David Abrahams
+:Contact: dave@boost-consulting.com
+:organization: `Boost Consulting`_
+:date: $Date$
+:copyright: Copyright David Abrahams 2004. 
+
+.. _`Boost Consulting`: http://www.boost-consulting.com
+
+:abstract: Header ``<boost/iterator/iterator_traits.hpp>`` provides
+  the ability to access an iterator's associated types using
+  MPL-compatible metafunctions_.
+
+.. _metafunctions: ../../mpl/doc/index.html#metafunctions
+
+Overview
+========
+
+``std::iterator_traits`` provides access to five associated types
+of any iterator: its ``value_type``, ``reference``, ``pointer``,
+``iterator_category``, and ``difference_type``.  Unfortunately,
+such a "multi-valued" traits template can be difficult to use in a
+metaprogramming context.  ``<boost/iterator/iterator_traits.hpp>``
+provides access to these types using a standard metafunctions_.
+
+Summary
+=======
+
+Header ``<boost/iterator/iterator_traits.hpp>``::
+
+  template <class Iterator>
+  struct iterator_value
+  {
+      typedef typename 
+        std::iterator_traits<Iterator>::value_type 
+      type;
+  };
+
+  template <class Iterator>
+  struct iterator_reference
+  {
+      typedef typename 
+        std::iterator_traits<Iterator>::reference
+      type;
+  };
+
+
+  template <class Iterator>
+  struct iterator_pointer
+  {
+      typedef typename 
+        std::iterator_traits<Iterator>::pointer 
+      type;
+  };
+
+  template <class Iterator>
+  struct iterator_difference
+  {
+      typedef typename
+        detail::iterator_traits<Iterator>::difference_type
+      type;
+  };
+
+  template <class Iterator>
+  struct iterator_category
+  {
+      typedef typename
+        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/make_filter_iterator.html

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title></title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<div class="document">
+<pre class="literal-block">
+template &lt;class Predicate, class Iterator&gt;
+filter_iterator&lt;Predicate,Iterator&gt;
+make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());
+</pre>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">filter_iterator&lt;Predicate,Iterator&gt;(f, x, end)</td>
+</tr>
+</tbody>
+</table>
+<pre class="literal-block">
+template &lt;class Predicate, class Iterator&gt;
+filter_iterator&lt;Predicate,Iterator&gt;
+make_filter_iterator(Iterator x, Iterator end = Iterator());
+</pre>
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">filter_iterator&lt;Predicate,Iterator&gt;(x, end)</td>
+</tr>
+</tbody>
+</table>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="make_filter_iterator.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/make_zip_iterator.rst

@@ -0,0 +1,8 @@
+::
+
+    template<typename IteratorTuple> 
+    zip_iterator<IteratorTuple> 
+    make_zip_iterator(IteratorTuple t);
+
+:Returns: An instance of ``zip_iterator<IteratorTuple>`` with ``m_iterator_tuple``
+  initialized to ``t``.

doc/new-iter-concepts.rst

@@ -17,7 +17,7 @@
          revision of paper n1297_, n1477_, and n1531_.
 
 :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt
-         2003. All rights reserved
+         2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu
@@ -163,10 +163,9 @@ to express their type requirements. The result is algorithms that are
 usable in more situations and have fewer type requirements.
 
 For the next working paper (but not for TR1), the committee should
-consider the following changes to the type requirements of
-algorithms.  These changes are phrased as phrased as textual
-substitutions, listing the algorithms to which each textual
-substitution applies.
+consider the following changes to the type requirements of algorithms.
+These changes are phrased as textual substitutions, listing the
+algorithms to which each textual substitution applies.
 
 Forward Iterator -> Forward Traversal Iterator and Readable Iterator
 
@@ -413,8 +412,9 @@ expressions are valid and respect the stated semantics.
 |                         |             |exchanged                    |
 +-------------------------+-------------+-----------------------------+
 
-[*Note:* An iterator that is a model of the *Readable* and *Writable Iterator* concepts
-  is also a model of *Swappable Iterator*.  *--end note*]
+[*Note:* An iterator that is a model of the `Readable Iterator`_ and
+`Writable Iterator`_ concepts is also a model of *Swappable
+Iterator*.  *--end note*]
 
 
 Lvalue Iterators [lib.lvalue.iterators]
@@ -422,7 +422,7 @@ Lvalue Iterators [lib.lvalue.iterators]
 
 The *Lvalue Iterator* concept adds the requirement that the return
 type of ``operator*`` type be a reference to the value type of the
-iterator.
+iterator.  
 
 +-------------------------------------------------------------+
 | Lvalue Iterator Requirements                                |
@@ -432,13 +432,14 @@ iterator.
 |``*a``       | ``T&``    |``T`` is *cv*                      |
 |             |           |``iterator_traits<X>::value_type`` |
 |             |           |where *cv* is an optional          |
-|             |           |cv-qualification.                  |
-|             |           |pre: ``a`` is                      |
-|             |           |dereferenceable. If ``a            |
-|             |           |== b`` then ``*a`` is              |
-|             |           |equivalent to ``*b``.              |
+|             |           |cv-qualification.  pre: ``a`` is   |
+|             |           |dereferenceable.                   |
 +-------------+-----------+-----------------------------------+
 
+If ``X`` is a `Writable Iterator`_ then ``a == b`` if and only if
+``*a`` is the same object as ``*b``.  If ``X`` is a `Readable
+Iterator`_ then ``a == b`` implies ``*a`` is the same object as
+``*b``.
 
 
 Iterator Traversal Concepts [lib.iterator.traversal]
@@ -449,7 +450,6 @@ constant objects of type ``X``, ``r`` and ``s`` are mutable objects of
 type ``X``, ``T`` is ``std::iterator_traits<X>::value_type``, and
 ``v`` is a constant object of type ``T``.
 
-
 Incrementable Iterators [lib.incrementable.iterators]
 -----------------------------------------------------
 
@@ -458,26 +458,28 @@ concept if, in addition to ``X`` being Assignable and Copy
 Constructible, the following expressions are valid and respect the
 stated semantics.
 
++------------------------------------------------------------------------------------+
+|Incrementable Iterator Requirements (in addition to Assignable, Copy Constructible) |
+|                                                                                    |
++--------------------------------+-------------------------------+-------------------+
+|Expression                      |Return Type                    |Assertion          |
++================================+===============================+===================+
+|``++r``                         |``X&``                         |``&r == &++r``     |
++--------------------------------+-------------------------------+-------------------+
+|``r++``                         |                               |                   |
++--------------------------------+-------------------------------+-------------------+
+|``*r++``                        |                               |                   |
++--------------------------------+-------------------------------+-------------------+
+|``iterator_traversal<X>::type`` |Convertible to                 |                   |
+|                                |``incrementable_traversal_tag``|                   |
++--------------------------------+-------------------------------+-------------------+
 
-+-------------------------------------------------------------------------------------+
-|Incrementable Iterator Requirements (in addition to Assignable, Copy Constructible)  |
-|                                                                                     |
-+--------------------------------+-------------------------------+--------------------+
-|Expression                      |Return Type                    |Assertion/Semantics |
-+================================+===============================+====================+
-|``++r``                         |``X&``                         |``&r == &++r``      |
-+--------------------------------+-------------------------------+--------------------+
-|``r++``                         |``X``                          |::                  |
-|                                |                               |                    |
-|                                |                               | {                  |
-|                                |                               |    X tmp = r;      |
-|                                |                               |    ++r;            |
-|                                |                               |    return tmp;     |
-|                                |                               | }                  |
-+--------------------------------+-------------------------------+--------------------+
-|``iterator_traversal<X>::type`` |Convertible to                 |                    |
-|                                |``incrementable_traversal_tag``|                    |
-+--------------------------------+-------------------------------+--------------------+
+
+If ``X`` is a `Writable Iterator`_ then ``X a(r++);`` is equivalent
+to ``X a(r); ++r;`` and ``*r++ = o`` is equivalent
+to  ``*r = o; ++r``.
+If ``X`` is a `Readable Iterator`_ then ``T z(*r++);`` is equivalent
+to ``T z(*r); ++r;``. 
 
 .. TR1: incrementable_iterator_tag changed to
    incrementable_traversal_tag for consistency.
@@ -490,26 +492,26 @@ concept if the following expressions are valid and respect the stated
 semantics.
 
 
-+------------------------------------------------------------------------------------------+
-|Single Pass Iterator Requirements (in addition to Incrementable Iterator and Equality     |
-|Comparable)                                                                               |
-+--------------------------------+-----------------------------+---------------------------+
-|Expression                      |Return Type                  |Assertion/Semantics /      | 
-|                                |                             |Pre-/Post-condition        |
-+================================+=============================+===========================+
-|``++r``                         |``X&``                       |pre: ``r`` is              |
-|                                |                             |dereferenceable; post:     |
-|                                |                             |``r`` is dereferenceable or|
-|                                |                             |``r`` is past-the-end      |
-+--------------------------------+-----------------------------+---------------------------+
-|``a == b``                      |convertible to ``bool``      |``==`` is an equivalence   |
-|                                |                             |relation over its domain   |
-+--------------------------------+-----------------------------+---------------------------+
-|``a != b``                      |convertible to ``bool``      |``!(a == b)``              |
-+--------------------------------+-----------------------------+---------------------------+
-|``iterator_traversal<X>::type`` |Convertible to               |                           |
-|                                |``single_pass_traversal_tag``|                           |
-+--------------------------------+-----------------------------+---------------------------+
++--------------------------------------------------------------------------------------------------------+
+|Single Pass Iterator Requirements (in addition to Incrementable Iterator and Equality                   |
+|Comparable)                                                                                             |
++--------------------------------+-----------------------------+-------------+---------------------------+
+|Expression                      |Return Type                  | Operational |Assertion/                 | 
+|                                |                             | Semantics   |Pre-/Post-condition        |
++================================+=============================+=============+===========================+
+|``++r``                         |``X&``                       |             |pre: ``r`` is              |
+|                                |                             |             |dereferenceable; post:     |
+|                                |                             |             |``r`` is dereferenceable or|
+|                                |                             |             |``r`` is past-the-end      |
++--------------------------------+-----------------------------+-------------+---------------------------+
+|``a == b``                      |convertible to ``bool``      |             |``==`` is an equivalence   |
+|                                |                             |             |relation over its domain   |
++--------------------------------+-----------------------------+-------------+---------------------------+
+|``a != b``                      |convertible to ``bool``      |``!(a == b)``|                           |
++--------------------------------+-----------------------------+-------------+---------------------------+
+|``iterator_traversal<X>::type`` |Convertible to               |             |                           |
+|                                |``single_pass_traversal_tag``|             |                           |
++--------------------------------+-----------------------------+-------------+---------------------------+
 
 .. TR1: single_pass_iterator_tag changed to
    single_pass_traversal_tag for consistency
@@ -521,7 +523,7 @@ Forward Traversal Iterators [lib.forward.traversal.iterators]
 A class or built-in type ``X`` models the *Forward Traversal Iterator*
 concept if, in addition to ``X`` meeting the requirements of Default
 Constructible and Single Pass Iterator, the following expressions are
-valid and respect the stated semantics.
+valid and respect the stated semantics. 
 
 +--------------------------------------------------------------------------------------------------------+
 |Forward Traversal Iterator Requirements (in addition to Default Constructible and Single Pass Iterator) |
@@ -543,6 +545,8 @@ valid and respect the stated semantics.
 |                                       |``forward_traversal_tag``          |                            |
 +---------------------------------------+-----------------------------------+----------------------------+
 
+
+
 .. TR1: forward_traversal_iterator_tag changed to
    forward_traversal_tag for consistency
 
@@ -555,35 +559,36 @@ Iterator* concept if, in addition to ``X`` meeting the requirements of
 Forward Traversal Iterator, the following expressions are valid and
 respect the stated semantics.
 
-+--------------------------------------------------------------------------------------+
-|Bidirectional Traversal Iterator Requirements (in addition to Forward Traversal       |
-|Iterator)                                                                             |
-+--------------------------------+-------------------------------+---------------------+
-|Expression                      |Return Type                    |Assertion/Semantics /|
-|                                |                               |Pre-/Post-condition  |
-+================================+===============================+=====================+
-|``--r``                         |``X&``                         |pre: there exists    |
-|                                |                               |``s`` such that ``r  |
-|                                |                               |== ++s``.  post:     |
-|                                |                               |``s`` is             |
-|                                |                               |dereferenceable.     |
-|                                |                               |``--(++r) == r``.    |
-|                                |                               |``--r == --s``       |
-|                                |                               |implies ``r ==       |
-|                                |                               |s``. ``&r == &--r``. |
-+--------------------------------+-------------------------------+---------------------+
-|``r--``                         |convertible to ``const X&``    |::                   |
-|                                |                               |                     |
-|                                |                               | {                   |
-|                                |                               |   X tmp = r;        |
-|                                |                               |   --r;              |
-|                                |                               |   return tmp;       |
-|                                |                               | }                   |
-+--------------------------------+-------------------------------+---------------------+
-|``iterator_traversal<X>::type`` |Convertible to                 |                     |
-|                                |``bidirectional_traversal_tag``|                     |
-|                                |                               |                     |
-+--------------------------------+-------------------------------+---------------------+
++-----------------------------------------------------------------------------------------------------+
+|Bidirectional Traversal Iterator Requirements (in addition to Forward Traversal                      |
+|Iterator)                                                                                            |
++--------------------------------+-------------------------------+--------------+---------------------+
+|Expression                      |Return Type                    |  Operational |Assertion/           |
+|                                |                               |  Semantics   |Pre-/Post-condition  |
++================================+===============================+==============+=====================+
+|``--r``                         |``X&``                         |              |pre: there exists    |
+|                                |                               |              |``s`` such that ``r  |
+|                                |                               |              |== ++s``.  post:     |
+|                                |                               |              |``s`` is             |
+|                                |                               |              |dereferenceable.     |
+|                                |                               |              |                     |
+|                                |                               |              |``++(--r) == r``.    |
+|                                |                               |              |``--r == --s``       |
+|                                |                               |              |implies ``r ==       |
+|                                |                               |              |s``. ``&r == &--r``. |
++--------------------------------+-------------------------------+--------------+---------------------+
+|``r--``                         |convertible to ``const X&``    |::            |                     |
+|                                |                               |              |                     |
+|                                |                               | {            |                     |
+|                                |                               |   X tmp = r; |                     |
+|                                |                               |   --r;       |                     |
+|                                |                               |   return tmp;|                     |
+|                                |                               | }            |                     |
++--------------------------------+-------------------------------+--------------+---------------------+
+|``iterator_traversal<X>::type`` |Convertible to                 |              |                     |
+|                                |``bidirectional_traversal_tag``|              |                     |
+|                                |                               |              |                     |
++--------------------------------+-------------------------------+--------------+---------------------+
 
 .. TR1: bidirectional_traversal_iterator_tag changed to
    bidirectional_traversal_tag for consistency
@@ -632,11 +637,11 @@ constant object of type ``Distance``.
 |                               |                                 |                         |``a + n == b``.  ``b  |
 |                               |                                 |                         |== a + (b - a)``.     |
 +-------------------------------+---------------------------------+-------------------------+----------------------+
-|``a[n]``                       |convertible to T                 |``*(a + n)``             |pre: a is a `readable |
-|                               |                                 |                         |iterator`_            |
+|``a[n]``                       |convertible to T                 |``*(a + n)``             |pre: a is a `Readable |
+|                               |                                 |                         |Iterator`_            |
 +-------------------------------+---------------------------------+-------------------------+----------------------+
-|``a[n] = v``                   |convertible to T                 |``*(a + n) = v``         |pre: a is a `writable |
-|                               |                                 |                         |iterator`_            |
+|``a[n] = v``                   |convertible to T                 |``*(a + n) = v``         |pre: a is a `Writable |
+|                               |                                 |                         |Iterator`_            |
 +-------------------------------+---------------------------------+-------------------------+----------------------+
 |``a < b``                      |convertible to ``bool``          |``b - a > 0``            |``<`` is a total      |
 |                               |                                 |                         |ordering relation     |

doc/permutation_iterator.html

@@ -3,12 +3,12 @@
 <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.3.1: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.8: http://docutils.sourceforge.net/" />
 <title>Permutation Iterator</title>
 <meta name="author" content="Toon Knapen, David Abrahams, Roland Richter, Jeremy Siek" />
 <meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab" />
-<meta name="date" content="2004-01-13" />
-<meta name="copyright" content="Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. All rights reserved" />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003." />
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
@@ -26,12 +26,12 @@
 <td><a class="first reference" href="http://www.boost-consulting.com">Boost Consulting</a>, Indiana University <a class="last reference" href="http://www.osl.iu.edu">Open Systems
 Lab</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2004-01-13</td></tr>
+<td>2004-11-01</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. All rights reserved</td></tr>
+<td>Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003.</td></tr>
 </tbody>
 </table>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
@@ -42,13 +42,13 @@ in a potentially different order.</td>
 </tbody>
 </table>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
+<p class="topic-title first"><a name="table-of-contents">Table of Contents</a></p>
 <ul class="simple">
 <li><a class="reference" href="#introduction" id="id2" name="id2">Introduction</a></li>
 <li><a class="reference" href="#reference" id="id3" name="id3">Reference</a><ul>
-<li><a class="reference" href="#permutation-iterator-requirements" id="id4" name="id4"><tt class="literal"><span class="pre">permutation_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#permutation-iterator-models" id="id5" name="id5"><tt class="literal"><span class="pre">permutation_iterator</span></tt> models</a></li>
-<li><a class="reference" href="#permutation-iterator-operations" id="id6" name="id6"><tt class="literal"><span class="pre">permutation_iterator</span></tt> operations</a></li>
+<li><a class="reference" href="#permutation-iterator-requirements" id="id4" name="id4"><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> requirements</a></li>
+<li><a class="reference" href="#permutation-iterator-models" id="id5" name="id5"><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> models</a></li>
+<li><a class="reference" href="#permutation-iterator-operations" id="id6" name="id6"><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> operations</a></li>
 </ul>
 </li>
 <li><a class="reference" href="#example" id="id7" name="id7">Example</a></li>
@@ -108,54 +108,54 @@ permutation_iterator&lt;ElementIterator, IndexIterator&gt;
 make_permutation_iterator( ElementIterator e, IndexIterator i);
 </pre>
 <div class="section" id="permutation-iterator-requirements">
-<h2><a class="toc-backref" href="#id4" name="permutation-iterator-requirements"><tt class="literal"><span class="pre">permutation_iterator</span></tt> requirements</a></h2>
-<p><tt class="literal"><span class="pre">ElementIterator</span></tt> shall model Random Access Traversal Iterator.
-<tt class="literal"><span class="pre">IndexIterator</span></tt> shall model Readable Iterator.  The value type of
-the <tt class="literal"><span class="pre">IndexIterator</span></tt> must be convertible to the difference type of
-<tt class="literal"><span class="pre">ElementIterator</span></tt>.</p>
+<h2><a class="toc-backref" href="#id4" name="permutation-iterator-requirements"><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> requirements</a></h2>
+<p><tt class="docutils literal"><span class="pre">ElementIterator</span></tt> shall model Random Access Traversal Iterator.
+<tt class="docutils literal"><span class="pre">IndexIterator</span></tt> shall model Readable Iterator.  The value type of
+the <tt class="docutils literal"><span class="pre">IndexIterator</span></tt> must be convertible to the difference type of
+<tt class="docutils literal"><span class="pre">ElementIterator</span></tt>.</p>
 </div>
 <div class="section" id="permutation-iterator-models">
-<h2><a class="toc-backref" href="#id5" name="permutation-iterator-models"><tt class="literal"><span class="pre">permutation_iterator</span></tt> models</a></h2>
-<p><tt class="literal"><span class="pre">permutation_iterator</span></tt> models the same iterator traversal concepts
-as <tt class="literal"><span class="pre">IndexIterator</span></tt> and the same iterator access concepts as
-<tt class="literal"><span class="pre">ElementIterator</span></tt>.</p>
-<p>If <tt class="literal"><span class="pre">IndexIterator</span></tt> models Single Pass Iterator and 
-<tt class="literal"><span class="pre">ElementIterator</span></tt> models Readable Iterator then
-<tt class="literal"><span class="pre">permutation_iterator</span></tt> models Input Iterator.</p>
-<p>If <tt class="literal"><span class="pre">IndexIterator</span></tt> models Forward Traversal Iterator and 
-<tt class="literal"><span class="pre">ElementIterator</span></tt> models Readable Lvalue Iterator then
-<tt class="literal"><span class="pre">permutation_iterator</span></tt> models Forward Iterator.</p>
-<p>If <tt class="literal"><span class="pre">IndexIterator</span></tt> models Bidirectional Traversal Iterator and 
-<tt class="literal"><span class="pre">ElementIterator</span></tt> models Readable Lvalue Iterator then
-<tt class="literal"><span class="pre">permutation_iterator</span></tt> models Bidirectional Iterator.</p>
-<p>If <tt class="literal"><span class="pre">IndexIterator</span></tt> models Random Access Traversal Iterator and
-<tt class="literal"><span class="pre">ElementIterator</span></tt> models Readable Lvalue Iterator then
-<tt class="literal"><span class="pre">permutation_iterator</span></tt> models Random Access Iterator.</p>
-<p><tt class="literal"><span class="pre">permutation_iterator&lt;E1,</span> <span class="pre">X,</span> <span class="pre">V1,</span> <span class="pre">C2,</span> <span class="pre">R1,</span> <span class="pre">D1&gt;</span></tt> is interoperable
-with <tt class="literal"><span class="pre">permutation_iterator&lt;E2,</span> <span class="pre">Y,</span> <span class="pre">V2,</span> <span class="pre">C2,</span> <span class="pre">R2,</span> <span class="pre">D2&gt;</span></tt> if and only if
-<tt class="literal"><span class="pre">X</span></tt> is interoperable with <tt class="literal"><span class="pre">Y</span></tt> and <tt class="literal"><span class="pre">E1</span></tt> is convertible
-to <tt class="literal"><span class="pre">E2</span></tt>.</p>
+<h2><a class="toc-backref" href="#id5" name="permutation-iterator-models"><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> models</a></h2>
+<p><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> models the same iterator traversal concepts
+as <tt class="docutils literal"><span class="pre">IndexIterator</span></tt> and the same iterator access concepts as
+<tt class="docutils literal"><span class="pre">ElementIterator</span></tt>.</p>
+<p>If <tt class="docutils literal"><span class="pre">IndexIterator</span></tt> models Single Pass Iterator and 
+<tt class="docutils literal"><span class="pre">ElementIterator</span></tt> models Readable Iterator then
+<tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> models Input Iterator.</p>
+<p>If <tt class="docutils literal"><span class="pre">IndexIterator</span></tt> models Forward Traversal Iterator and 
+<tt class="docutils literal"><span class="pre">ElementIterator</span></tt> models Readable Lvalue Iterator then
+<tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> models Forward Iterator.</p>
+<p>If <tt class="docutils literal"><span class="pre">IndexIterator</span></tt> models Bidirectional Traversal Iterator and 
+<tt class="docutils literal"><span class="pre">ElementIterator</span></tt> models Readable Lvalue Iterator then
+<tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> models Bidirectional Iterator.</p>
+<p>If <tt class="docutils literal"><span class="pre">IndexIterator</span></tt> models Random Access Traversal Iterator and
+<tt class="docutils literal"><span class="pre">ElementIterator</span></tt> models Readable Lvalue Iterator then
+<tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> models Random Access Iterator.</p>
+<p><tt class="docutils literal"><span class="pre">permutation_iterator&lt;E1,</span> <span class="pre">X,</span> <span class="pre">V1,</span> <span class="pre">C2,</span> <span class="pre">R1,</span> <span class="pre">D1&gt;</span></tt> is interoperable
+with <tt class="docutils literal"><span class="pre">permutation_iterator&lt;E2,</span> <span class="pre">Y,</span> <span class="pre">V2,</span> <span class="pre">C2,</span> <span class="pre">R2,</span> <span class="pre">D2&gt;</span></tt> if and only if
+<tt class="docutils literal"><span class="pre">X</span></tt> is interoperable with <tt class="docutils literal"><span class="pre">Y</span></tt> and <tt class="docutils literal"><span class="pre">E1</span></tt> is convertible
+to <tt class="docutils literal"><span class="pre">E2</span></tt>.</p>
 </div>
 <div class="section" id="permutation-iterator-operations">
-<h2><a class="toc-backref" href="#id6" name="permutation-iterator-operations"><tt class="literal"><span class="pre">permutation_iterator</span></tt> operations</a></h2>
+<h2><a class="toc-backref" href="#id6" name="permutation-iterator-operations"><tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> operations</a></h2>
 <p>In addition to those operations required by the concepts that
-<tt class="literal"><span class="pre">permutation_iterator</span></tt> models, <tt class="literal"><span class="pre">permutation_iterator</span></tt> provides the
+<tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> models, <tt class="docutils literal"><span class="pre">permutation_iterator</span></tt> provides the
 following operations.</p>
-<p><tt class="literal"><span class="pre">permutation_iterator();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">permutation_iterator();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Default constructs <tt class="literal"><span class="pre">m_elt</span></tt> and <tt class="literal"><span class="pre">m_order</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Default constructs <tt class="docutils literal"><span class="pre">m_elt</span></tt> and <tt class="docutils literal"><span class="pre">m_order</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">explicit</span> <span class="pre">permutation_iterator(ElementIterator</span> <span class="pre">x,</span> <span class="pre">IndexIterator</span> <span class="pre">y);</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">explicit</span> <span class="pre">permutation_iterator(ElementIterator</span> <span class="pre">x,</span> <span class="pre">IndexIterator</span> <span class="pre">y);</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs <tt class="literal"><span class="pre">m_elt</span></tt> from <tt class="literal"><span class="pre">x</span></tt> and <tt class="literal"><span class="pre">m_order</span></tt> from <tt class="literal"><span class="pre">y</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs <tt class="docutils literal"><span class="pre">m_elt</span></tt> from <tt class="docutils literal"><span class="pre">x</span></tt> and <tt class="docutils literal"><span class="pre">m_order</span></tt> from <tt class="docutils literal"><span class="pre">y</span></tt>.</td>
 </tr>
 </tbody>
 </table>
@@ -167,41 +167,41 @@ permutation_iterator(
     , typename enable_if_convertible&lt;OIIter, IndexIterator&gt;::type* = 0
     );
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs <tt class="literal"><span class="pre">m_elt</span></tt> from <tt class="literal"><span class="pre">r.m_elt</span></tt> and
-<tt class="literal"><span class="pre">m_order</span></tt> from <tt class="literal"><span class="pre">y.m_order</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs <tt class="docutils literal"><span class="pre">m_elt</span></tt> from <tt class="docutils literal"><span class="pre">r.m_elt</span></tt> and
+<tt class="docutils literal"><span class="pre">m_order</span></tt> from <tt class="docutils literal"><span class="pre">y.m_order</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*(m_elt</span> <span class="pre">+</span> <span class="pre">*m_order)</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*(m_elt</span> <span class="pre">+</span> <span class="pre">*m_order)</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">permutation_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">permutation_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">++m_order</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">++m_order</span></tt></td>
 </tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*this</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">ElementIterator</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">ElementIterator</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_order</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">m_order</span></tt></td>
 </tr>
 </tbody>
 </table>
@@ -210,11 +210,11 @@ template &lt;class ElementIterator, class IndexIterator&gt;
 permutation_iterator&lt;ElementIterator, IndexIterator&gt; 
 make_permutation_iterator(ElementIterator e, IndexIterator i);
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">permutation_iterator&lt;ElementIterator,</span> <span class="pre">IndexIterator&gt;(e,</span> <span class="pre">i)</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">permutation_iterator&lt;ElementIterator,</span> <span class="pre">IndexIterator&gt;(e,</span> <span class="pre">i)</span></tt></td>
 </tr>
 </tbody>
 </table>
@@ -283,10 +283,10 @@ Elements at even indices in the permutation : 9 7
 Permutation backwards : 6 7 8 9 
 Iterate backward with stride 2 : 6 8 
 </pre>
-<p>The source code for this example can be found <a class="reference" href="../example/permutation_iterator_example.cpp">here</a>.</p>
+<p>The source code for this example can be found <a class="reference" href="../example/permutation_iter_example.cpp">here</a>.</p>
 </div>
 </div>
-<hr class="footer" />
+<hr class="docutils footer" />
 <div class="footer">
 <a class="reference" href="permutation_iterator.rst">View document source</a>.
 Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.

doc/permutation_iterator.rst

@@ -7,14 +7,14 @@
 :organization: `Boost Consulting`_, Indiana University `Open Systems
                Lab`_
 :date: $Date$
-:copyright: Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. All rights reserved
+:copyright: Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu
 
 :abstract:
 
-  .. include:: permutation_iterator_abstract.rst
+  .. include:: permutation_iter_abstract.rst
 
 .. contents:: Table of Contents
 

doc/permutation_iterator_eg.rst

@@ -64,4 +64,4 @@ The output is::
 
 The source code for this example can be found `here`__.
 
-__ ../example/permutation_iterator_example.cpp
+__ ../example/permutation_iter_example.cpp

doc/pointee.html

@@ -3,17 +3,17 @@
 <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.3.1: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.8: http://docutils.sourceforge.net/" />
 <title>pointee and indirect_reference</title>
 <meta name="author" content="David Abrahams" />
 <meta name="organization" content="Boost Consulting" />
-<meta name="date" content="2004-01-13" />
-<meta name="copyright" content="Copyright David Abrahams 2004. All rights reserved" />
+<meta name="date" content="2005-02-27" />
+<meta name="copyright" content="Copyright David Abrahams 2004." />
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
 <div class="document" id="pointee-and-indirect-reference">
-<h1 class="title"><tt class="literal"><span class="pre">pointee</span></tt> and <tt class="literal"><span class="pre">indirect_reference</span></tt></h1>
+<h1 class="title"><tt class="docutils literal"><span class="pre">pointee</span></tt> and <tt class="docutils literal"><span class="pre">indirect_reference</span></tt></h1>
 <table class="docinfo" frame="void" rules="none">
 <col class="docinfo-name" />
 <col class="docinfo-content" />
@@ -21,16 +21,16 @@
 <tr><th class="docinfo-name">Author:</th>
 <td>David Abrahams</td></tr>
 <tr><th class="docinfo-name">Contact:</th>
-<td><a class="first reference" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a>, <a class="reference" href="mailto:jsiek&#64;osl.iu.edu">jsiek&#64;osl.iu.edu</a>, <a class="last reference" href="mailto:witt&#64;ive.uni-hannover.de">witt&#64;ive.uni-hannover.de</a></td></tr>
+<td><a class="first last reference" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a></td></tr>
 <tr><th class="docinfo-name">Organization:</th>
 <td><a class="first last reference" href="http://www.boost-consulting.com">Boost Consulting</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2004-01-13</td></tr>
+<td>2005-02-27</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams 2004. All rights reserved</td></tr>
+<td>Copyright David Abrahams 2004.</td></tr>
 </tbody>
 </table>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
@@ -54,16 +54,16 @@ void f(Dereferenceable p)
 }
 </pre>
 <div class="section" id="pointee">
-<h2><a name="pointee"><tt class="literal"><span class="pre">pointee</span></tt></a></h2>
+<h2><a name="pointee"><tt class="docutils literal"><span class="pre">pointee</span></tt></a></h2>
 <p>It turns out to be impossible to come up with a fully-general
 algorithm to do determine <em>what-goes-here</em> directly, but it is
-possible to require that <tt class="literal"><span class="pre">pointee&lt;Dereferenceable&gt;::type</span></tt> is
-correct. Naturally, <tt class="literal"><span class="pre">pointee</span></tt> has the same difficulty: it can't
-determine the appropriate <tt class="literal"><span class="pre">::type</span></tt> reliably for all
-<tt class="literal"><span class="pre">Dereferenceable</span></tt>s, but it makes very good guesses (it works
+possible to require that <tt class="docutils literal"><span class="pre">pointee&lt;Dereferenceable&gt;::type</span></tt> is
+correct. Naturally, <tt class="docutils literal"><span class="pre">pointee</span></tt> has the same difficulty: it can't
+determine the appropriate <tt class="docutils literal"><span class="pre">::type</span></tt> reliably for all
+<tt class="docutils literal"><span class="pre">Dereferenceable</span></tt>s, but it makes very good guesses (it works
 for all pointers, standard and boost smart pointers, and
 iterators), and when it guesses wrongly, it can be specialized as
-neccessary:</p>
+necessary:</p>
 <pre class="literal-block">
 namespace boost
 {
@@ -76,21 +76,21 @@ namespace boost
 </pre>
 </div>
 <div class="section" id="indirect-reference">
-<h2><a name="indirect-reference"><tt class="literal"><span class="pre">indirect_reference</span></tt></a></h2>
-<p><tt class="literal"><span class="pre">indirect_reference&lt;T&gt;::type</span></tt> is rather more specialized than
-<tt class="literal"><span class="pre">pointee</span></tt>, and is meant to be used to forward the result of
+<h2><a name="indirect-reference"><tt class="docutils literal"><span class="pre">indirect_reference</span></tt></a></h2>
+<p><tt class="docutils literal"><span class="pre">indirect_reference&lt;T&gt;::type</span></tt> is rather more specialized than
+<tt class="docutils literal"><span class="pre">pointee</span></tt>, and is meant to be used to forward the result of
 dereferencing an object of its argument type.  Most dereferenceable
 types just return a reference to their pointee, but some return
 proxy references or return the pointee by value.  When that
-information is needed, call on <tt class="literal"><span class="pre">indirect_reference</span></tt>.</p>
+information is needed, call on <tt class="docutils literal"><span class="pre">indirect_reference</span></tt>.</p>
 <p>Both of these templates are essential to the correct functioning of
-<a class="reference" href="indirect_iterator.html"><tt class="literal"><span class="pre">indirect_iterator</span></tt></a>.</p>
+<a class="reference" href="indirect_iterator.html"><tt class="docutils literal"><span class="pre">indirect_iterator</span></tt></a>.</p>
 </div>
 </div>
 <div class="section" id="reference">
 <h1><a name="reference">Reference</a></h1>
 <div class="section" id="id1">
-<h2><a name="id1"><tt class="literal"><span class="pre">pointee</span></tt></a></h2>
+<h2><a name="id1"><tt class="docutils literal"><span class="pre">pointee</span></tt></a></h2>
 <!-- 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) -->
@@ -101,22 +101,22 @@ struct pointee
     typedef /* see below */ type;
 };
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Requires:</th><td class="field-body">For an object <tt class="literal"><span class="pre">x</span></tt> of type <tt class="literal"><span class="pre">Dereferenceable</span></tt>, <tt class="literal"><span class="pre">*x</span></tt>
-is well-formed.  If <tt class="literal"><span class="pre">++x</span></tt> is ill-formed it shall neither be
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body">For an object <tt class="docutils literal"><span class="pre">x</span></tt> of type <tt class="docutils literal"><span class="pre">Dereferenceable</span></tt>, <tt class="docutils literal"><span class="pre">*x</span></tt>
+is well-formed.  If <tt class="docutils literal"><span class="pre">++x</span></tt> is ill-formed it shall neither be
 ambiguous nor shall it violate access control, and
-<tt class="literal"><span class="pre">Dereferenceable::element_type</span></tt> shall be an accessible type.
-Otherwise <tt class="literal"><span class="pre">iterator_traits&lt;Dereferenceable&gt;::value_type</span></tt> shall
+<tt class="docutils literal"><span class="pre">Dereferenceable::element_type</span></tt> shall be an accessible type.
+Otherwise <tt class="docutils literal"><span class="pre">iterator_traits&lt;Dereferenceable&gt;::value_type</span></tt> shall
 be well formed.  [Note: These requirements need not apply to
-explicit or partial specializations of <tt class="literal"><span class="pre">pointee</span></tt>]</td>
+explicit or partial specializations of <tt class="docutils literal"><span class="pre">pointee</span></tt>]</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">type</span></tt> is determined according to the following algorithm, where
-<tt class="literal"><span class="pre">x</span></tt> is an object of type <tt class="literal"><span class="pre">Dereferenceable</span></tt>:</p>
+<p><tt class="docutils literal"><span class="pre">type</span></tt> is determined according to the following algorithm, where
+<tt class="docutils literal"><span class="pre">x</span></tt> is an object of type <tt class="docutils literal"><span class="pre">Dereferenceable</span></tt>:</p>
 <pre class="literal-block">
 if ( ++x is ill-formed )
 {
@@ -134,7 +134,7 @@ else
 </pre>
 </div>
 <div class="section" id="id2">
-<h2><a name="id2"><tt class="literal"><span class="pre">indirect_reference</span></tt></a></h2>
+<h2><a name="id2"><tt class="docutils literal"><span class="pre">indirect_reference</span></tt></a></h2>
 <!-- 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) -->
@@ -145,22 +145,22 @@ struct indirect_reference
     typedef /* see below */ type;
 };
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Requires:</th><td class="field-body">For an object <tt class="literal"><span class="pre">x</span></tt> of type <tt class="literal"><span class="pre">Dereferenceable</span></tt>, <tt class="literal"><span class="pre">*x</span></tt>
-is well-formed.  If <tt class="literal"><span class="pre">++x</span></tt> is ill-formed it shall neither be
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body">For an object <tt class="docutils literal"><span class="pre">x</span></tt> of type <tt class="docutils literal"><span class="pre">Dereferenceable</span></tt>, <tt class="docutils literal"><span class="pre">*x</span></tt>
+is well-formed.  If <tt class="docutils literal"><span class="pre">++x</span></tt> is ill-formed it shall neither be
 ambiguous nor shall it violate access control, and
-<tt class="literal"><span class="pre">pointee&lt;Dereferenceable&gt;::type&amp;</span></tt> shall be well-formed.
-Otherwise <tt class="literal"><span class="pre">iterator_traits&lt;Dereferenceable&gt;::reference</span></tt> shall
+<tt class="docutils literal"><span class="pre">pointee&lt;Dereferenceable&gt;::type&amp;</span></tt> shall be well-formed.
+Otherwise <tt class="docutils literal"><span class="pre">iterator_traits&lt;Dereferenceable&gt;::reference</span></tt> shall
 be well formed.  [Note: These requirements need not apply to
-explicit or partial specializations of <tt class="literal"><span class="pre">indirect_reference</span></tt>]</td>
+explicit or partial specializations of <tt class="docutils literal"><span class="pre">indirect_reference</span></tt>]</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">type</span></tt> is determined according to the following algorithm, where
-<tt class="literal"><span class="pre">x</span></tt> is an object of type <tt class="literal"><span class="pre">Dereferenceable</span></tt>:</p>
+<p><tt class="docutils literal"><span class="pre">type</span></tt> is determined according to the following algorithm, where
+<tt class="docutils literal"><span class="pre">x</span></tt> is an object of type <tt class="docutils literal"><span class="pre">Dereferenceable</span></tt>:</p>
 <pre class="literal-block">
 if ( ++x is ill-formed )
     return ``pointee&lt;Dereferenceable&gt;::type&amp;``
@@ -170,7 +170,7 @@ else
 </div>
 </div>
 </div>
-<hr class="footer" />
+<hr class="docutils footer" />
 <div class="footer">
 <a class="reference" href="pointee.rst">View document source</a>.
 Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.

doc/pointee.rst

@@ -1,12 +1,12 @@
 ++++++++++++++++++++++++++++++++++++++++
- ``pointee`` and ``indirect_reference``
+ ``pointee`` and ``indirect_reference`` 
 ++++++++++++++++++++++++++++++++++++++++
 
 :Author: David Abrahams
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@ive.uni-hannover.de
+:Contact: dave@boost-consulting.com
 :organization: `Boost Consulting`_
 :date: $Date$
-:copyright: Copyright David Abrahams 2004. All rights reserved
+:copyright: Copyright David Abrahams 2004. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 
@@ -42,7 +42,7 @@ determine the appropriate ``::type`` reliably for all
 ``Dereferenceable``\ s, but it makes very good guesses (it works
 for all pointers, standard and boost smart pointers, and
 iterators), and when it guesses wrongly, it can be specialized as
-neccessary::
+necessary::
 
   namespace boost
   {

doc/ref_problem.html

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<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.3.6: http://docutils.sourceforge.net/" />
+<title>Problem with reference and old/new iterator category correspondance</title>
+<link rel="stylesheet" href="default.css" type="text/css" />
+</head>
+<body>
+<h1 class="title">Problem with <tt class="literal"><span class="pre">reference</span></tt> and old/new iterator category correspondance</h1>
+<div class="document" id="problem-with-reference-and-old-new-iterator-category-correspondance">
+<table class="field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field"><th class="field-name">Author:</th><td class="field-body">David Abrahams and Jeremy Siek</td>
+</tr>
+<tr class="field"><th class="field-name">Contact:</th><td class="field-body"><a class="reference" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a>, <a class="reference" href="mailto:jsiek&#64;osl.iu.edu">jsiek&#64;osl.iu.edu</a></td>
+</tr>
+<tr class="field"><th class="field-name">Organization:</th><td class="field-body"><a class="reference" href="http://www.boost-consulting.com">Boost Consulting</a>, Indiana University Bloomington</td>
+</tr>
+<tr class="field"><th class="field-name">date:</th><td class="field-body">$Date$</td>
+</tr>
+<tr class="field"><th class="field-name">Copyright:</th><td class="field-body">Copyright David Abrahams, Jeremy Siek 2003. Use, modification and
+distribution is subject to the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt or copy
+at <a class="reference" href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</td>
+</tr>
+</tbody>
+</table>
+<div class="section" id="introduction">
+<h1><a name="introduction">Introduction</a></h1>
+<p>The new iterator categories are intended to correspond to the old
+iterator categories, as specified in a diagram in <a class="reference" href="http://www.boost-consulting.com/writing/n1550.html">N1550</a>. For example,
+an iterator categorized as a mutable Forward Iterator under the old
+scheme is now a Writable, Lvalue, and Foward Traversal iterator.
+However, there is a problem with this correspondance, the new iterator
+categories place requirements on the <tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::reference</span></tt>
+type whereas the standard iterator requirements say nothing about the
+<tt class="literal"><span class="pre">reference</span></tt> type . In particular, the new Readable Iterator
+requirements say that the return type of <tt class="literal"><span class="pre">*a</span></tt> must be
+<tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::reference</span></tt> and the Lvalue Iterator requirements
+says that <tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::reference</span></tt> must be <tt class="literal"><span class="pre">T&amp;</span></tt> or <tt class="literal"><span class="pre">const</span>
+<span class="pre">T&amp;</span></tt>.</p>
+</div>
+<div class="section" id="proposed-resolution">
+<h1><a name="proposed-resolution">Proposed Resolution</a></h1>
+<p>Change the standard requirements to match the requirements of the new
+iterators. (more details to come)</p>
+</div>
+<div class="section" id="rationale">
+<h1><a name="rationale">Rationale</a></h1>
+<p>The lack of specification in the standard of the <tt class="literal"><span class="pre">reference</span></tt> type is
+certainly a defect. Without specification, it is entirely useless in a
+generic function. The current practice in the community is generally
+to assume there are requirements on the <tt class="literal"><span class="pre">reference</span></tt> type, such as
+those proposed in the new iterator categories.</p>
+<p>There is some danger in <em>adding</em> requirements to existing concepts.
+This will mean that some existing iterator types will no longer meet
+the iterator requirements. However, we feel that the impact of this is
+small enough to warrant going ahead with this change.</p>
+<p>An alternative solution would be to leave the standard requirements as
+is, and to remove the requirements for the <tt class="literal"><span class="pre">reference</span></tt> type in the
+new iterator concepts. We are not in favor of this approach because it
+extends what we see as a defect further into the future.</p>
+</div>
+</div>
+<hr class="footer" />
+<div class="footer">
+<a class="reference" href="ref_problem.rst">View document source</a>.
+Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
+</div>
+</body>
+</html>

doc/reverse_iterator.html

@@ -3,12 +3,12 @@
 <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.3.1: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.8: http://docutils.sourceforge.net/" />
 <title>Reverse Iterator</title>
 <meta name="author" content="David Abrahams, Jeremy Siek, Thomas Witt" />
 <meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab, University of Hanover Institute for Transport Railway Operation and Construction" />
-<meta name="date" content="2004-01-13" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
+<meta name="date" content="2004-11-01" />
+<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003." />
 <link rel="stylesheet" href="default.css" type="text/css" />
 </head>
 <body>
@@ -27,12 +27,12 @@
 Lab</a>, University of Hanover <a class="last reference" href="http://www.ive.uni-hannover.de">Institute for Transport
 Railway Operation and Construction</a></td></tr>
 <tr><th class="docinfo-name">Date:</th>
-<td>2004-01-13</td></tr>
+<td>2004-11-01</td></tr>
 <tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
+<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.</td></tr>
 </tbody>
 </table>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
@@ -42,17 +42,17 @@ range in the opposite direction.</td>
 </tbody>
 </table>
 <div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
+<p class="topic-title first"><a name="table-of-contents">Table of Contents</a></p>
 <ul class="simple">
-<li><a class="reference" href="#reverse-iterator-synopsis" id="id2" name="id2"><tt class="literal"><span class="pre">reverse_iterator</span></tt> synopsis</a></li>
-<li><a class="reference" href="#reverse-iterator-requirements" id="id3" name="id3"><tt class="literal"><span class="pre">reverse_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#reverse-iterator-models" id="id4" name="id4"><tt class="literal"><span class="pre">reverse_iterator</span></tt> models</a></li>
-<li><a class="reference" href="#reverse-iterator-operations" id="id5" name="id5"><tt class="literal"><span class="pre">reverse_iterator</span></tt> operations</a></li>
+<li><a class="reference" href="#reverse-iterator-synopsis" id="id2" name="id2"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> synopsis</a></li>
+<li><a class="reference" href="#reverse-iterator-requirements" id="id3" name="id3"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> requirements</a></li>
+<li><a class="reference" href="#reverse-iterator-models" id="id4" name="id4"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> models</a></li>
+<li><a class="reference" href="#reverse-iterator-operations" id="id5" name="id5"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> operations</a></li>
 <li><a class="reference" href="#example" id="id6" name="id6">Example</a></li>
 </ul>
 </div>
 <div class="section" id="reverse-iterator-synopsis">
-<h1><a class="toc-backref" href="#id2" name="reverse-iterator-synopsis"><tt class="literal"><span class="pre">reverse_iterator</span></tt> synopsis</a></h1>
+<h1><a class="toc-backref" href="#id2" name="reverse-iterator-synopsis"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> synopsis</a></h1>
 <pre class="literal-block">
 template &lt;class Iterator&gt;
 class reverse_iterator
@@ -80,32 +80,34 @@ private:
   Iterator m_iterator; // exposition
 };
 </pre>
-<p>If <tt class="literal"><span class="pre">Iterator</span></tt> models Random Access Traversal Iterator and Readable
-Lvalue Iterator, then <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to
-<tt class="literal"><span class="pre">random_access_iterator_tag</span></tt>. Otherwise, if
-<tt class="literal"><span class="pre">Iterator</span></tt> models Bidirectional Traversal Iterator and Readable
-Lvalue Iterator, then <tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to
-<tt class="literal"><span class="pre">bidirectional_iterator_tag</span></tt>. Otherwise, <tt class="literal"><span class="pre">iterator_category</span></tt> is
-convertible to <tt class="literal"><span class="pre">input_iterator_tag</span></tt>.</p>
+<p>If <tt class="docutils literal"><span class="pre">Iterator</span></tt> models Random Access Traversal Iterator and Readable
+Lvalue Iterator, then <tt class="docutils literal"><span class="pre">iterator_category</span></tt> is convertible to
+<tt class="docutils literal"><span class="pre">random_access_iterator_tag</span></tt>. Otherwise, if
+<tt class="docutils literal"><span class="pre">Iterator</span></tt> models Bidirectional Traversal Iterator and Readable
+Lvalue Iterator, then <tt class="docutils literal"><span class="pre">iterator_category</span></tt> is convertible to
+<tt class="docutils literal"><span class="pre">bidirectional_iterator_tag</span></tt>. Otherwise, <tt class="docutils literal"><span class="pre">iterator_category</span></tt> is
+convertible to <tt class="docutils literal"><span class="pre">input_iterator_tag</span></tt>.</p>
 </div>
 <div class="section" id="reverse-iterator-requirements">
-<h1><a class="toc-backref" href="#id3" name="reverse-iterator-requirements"><tt class="literal"><span class="pre">reverse_iterator</span></tt> requirements</a></h1>
-<p><tt class="literal"><span class="pre">Iterator</span></tt> must be a model of Bidirectional Traversal Iterator.</p>
+<h1><a class="toc-backref" href="#id3" name="reverse-iterator-requirements"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> requirements</a></h1>
+<p><tt class="docutils literal"><span class="pre">Iterator</span></tt> must be a model of Bidirectional Traversal Iterator.  The
+type <tt class="docutils literal"><span class="pre">iterator_traits&lt;Iterator&gt;::reference</span></tt> must be the type of
+<tt class="docutils literal"><span class="pre">*i</span></tt>, where <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>.</p>
 </div>
 <div class="section" id="reverse-iterator-models">
-<h1><a class="toc-backref" href="#id4" name="reverse-iterator-models"><tt class="literal"><span class="pre">reverse_iterator</span></tt> models</a></h1>
-<p>A specialization of <tt class="literal"><span class="pre">reverse_iterator</span></tt> models the same iterator
-traversal and iterator access concepts modeled by its <tt class="literal"><span class="pre">Iterator</span></tt>
+<h1><a class="toc-backref" href="#id4" name="reverse-iterator-models"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> models</a></h1>
+<p>A specialization of <tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> models the same iterator
+traversal and iterator access concepts modeled by its <tt class="docutils literal"><span class="pre">Iterator</span></tt>
 argument.  In addition, it may model old iterator concepts
 specified in the following table:</p>
-<table border class="table">
+<table border="1" class="docutils">
 <colgroup>
 <col width="53%" />
 <col width="47%" />
 </colgroup>
 <thead valign="bottom">
-<tr><th>If <tt class="literal"><span class="pre">I</span></tt> models</th>
-<th>then <tt class="literal"><span class="pre">reverse_iterator&lt;I&gt;</span></tt> models</th>
+<tr><th>If <tt class="docutils literal"><span class="pre">I</span></tt> models</th>
+<th>then <tt class="docutils literal"><span class="pre">reverse_iterator&lt;I&gt;</span></tt> models</th>
 </tr>
 </thead>
 <tbody valign="top">
@@ -127,34 +129,34 @@ Random Access Traversal Iterator</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">reverse_iterator&lt;X&gt;</span></tt> is interoperable with
-<tt class="literal"><span class="pre">reverse_iterator&lt;Y&gt;</span></tt> if and only if <tt class="literal"><span class="pre">X</span></tt> is interoperable with
-<tt class="literal"><span class="pre">Y</span></tt>.</p>
+<p><tt class="docutils literal"><span class="pre">reverse_iterator&lt;X&gt;</span></tt> is interoperable with
+<tt class="docutils literal"><span class="pre">reverse_iterator&lt;Y&gt;</span></tt> if and only if <tt class="docutils literal"><span class="pre">X</span></tt> is interoperable with
+<tt class="docutils literal"><span class="pre">Y</span></tt>.</p>
 </div>
 <div class="section" id="reverse-iterator-operations">
-<h1><a class="toc-backref" href="#id5" name="reverse-iterator-operations"><tt class="literal"><span class="pre">reverse_iterator</span></tt> operations</a></h1>
+<h1><a class="toc-backref" href="#id5" name="reverse-iterator-operations"><tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> operations</a></h1>
 <p>In addition to the operations required by the concepts modeled by
-<tt class="literal"><span class="pre">reverse_iterator</span></tt>, <tt class="literal"><span class="pre">reverse_iterator</span></tt> provides the following
+<tt class="docutils literal"><span class="pre">reverse_iterator</span></tt>, <tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> provides the following
 operations.</p>
-<p><tt class="literal"><span class="pre">reverse_iterator();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">reverse_iterator();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">Iterator</span></tt> must be Default Constructible.</td>
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="docutils literal"><span class="pre">Iterator</span></tt> must be Default Constructible.</td>
 </tr>
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="literal"><span class="pre">reverse_iterator</span></tt> with <tt class="literal"><span class="pre">m_iterator</span></tt> 
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> with <tt class="docutils literal"><span class="pre">m_iterator</span></tt> 
 default constructed.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">explicit</span> <span class="pre">reverse_iterator(Iterator</span> <span class="pre">x);</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">explicit</span> <span class="pre">reverse_iterator(Iterator</span> <span class="pre">x);</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="literal"><span class="pre">reverse_iterator</span></tt> with
-<tt class="literal"><span class="pre">m_iterator</span></tt> copy constructed from <tt class="literal"><span class="pre">x</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs an instance of <tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> with
+<tt class="docutils literal"><span class="pre">m_iterator</span></tt> copy constructed from <tt class="docutils literal"><span class="pre">x</span></tt>.</td>
 </tr>
 </tbody>
 </table>
@@ -165,28 +167,28 @@ reverse_iterator(
   , typename enable_if_convertible&lt;OtherIterator, Iterator&gt;::type* = 0 // exposition
 );
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="literal"><span class="pre">OtherIterator</span></tt> is implicitly convertible to <tt class="literal"><span class="pre">Iterator</span></tt>.</td>
+<tr class="field"><th class="field-name">Requires:</th><td class="field-body"><tt class="docutils literal"><span class="pre">OtherIterator</span></tt> is implicitly convertible to <tt class="docutils literal"><span class="pre">Iterator</span></tt>.</td>
 </tr>
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs instance of <tt class="literal"><span class="pre">reverse_iterator</span></tt> whose 
-<tt class="literal"><span class="pre">m_iterator</span></tt> subobject is constructed from <tt class="literal"><span class="pre">y.base()</span></tt>.</td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body">Constructs instance of <tt class="docutils literal"><span class="pre">reverse_iterator</span></tt> whose 
+<tt class="docutils literal"><span class="pre">m_iterator</span></tt> subobject is constructed from <tt class="docutils literal"><span class="pre">y.base()</span></tt>.</td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">Iterator</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">Iterator</span> <span class="pre">const&amp;</span> <span class="pre">base()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">m_iterator</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">reference</span> <span class="pre">operator*()</span> <span class="pre">const;</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
@@ -198,25 +200,25 @@ reverse_iterator(
 Iterator tmp = m_iterator;
 return *--tmp;
 </pre>
-<p><tt class="literal"><span class="pre">reverse_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">reverse_iterator&amp;</span> <span class="pre">operator++();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">--m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">--m_iterator</span></tt></td>
 </tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*this</span></tt></td>
 </tr>
 </tbody>
 </table>
-<p><tt class="literal"><span class="pre">reverse_iterator&amp;</span> <span class="pre">operator--();</span></tt></p>
-<table class="field-list" frame="void" rules="none">
+<p><tt class="docutils literal"><span class="pre">reverse_iterator&amp;</span> <span class="pre">operator--();</span></tt></p>
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="literal"><span class="pre">++m_iterator</span></tt></td>
+<tr class="field"><th class="field-name">Effects:</th><td class="field-body"><tt class="docutils literal"><span class="pre">++m_iterator</span></tt></td>
 </tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="literal"><span class="pre">*this</span></tt></td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><tt class="docutils literal"><span class="pre">*this</span></tt></td>
 </tr>
 </tbody>
 </table>
@@ -225,12 +227,12 @@ template &lt;class BidirectionalIterator&gt;
 reverse_iterator&lt;BidirectionalIterator&gt;n
 make_reverse_iterator(BidirectionalIterator x);
 </pre>
-<table class="field-list" frame="void" rules="none">
+<table class="docutils field-list" frame="void" rules="none">
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">reverse_iterator&lt;BidirectionalIterator&gt;</span></tt>
-with a <tt class="literal"><span class="pre">current</span></tt> constructed from <tt class="literal"><span class="pre">x</span></tt>.</td>
+<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="docutils literal"><span class="pre">reverse_iterator&lt;BidirectionalIterator&gt;</span></tt>
+with a <tt class="docutils literal"><span class="pre">current</span></tt> constructed from <tt class="docutils literal"><span class="pre">x</span></tt>.</td>
 </tr>
 </tbody>
 </table>
@@ -238,7 +240,7 @@ with a <tt class="literal"><span class="pre">current</span></tt> constructed fro
 <div class="section" id="example">
 <h1><a class="toc-backref" href="#id6" name="example">Example</a></h1>
 <p>The following example prints an array of characters in reverse order
-using <tt class="literal"><span class="pre">reverse_iterator</span></tt>.</p>
+using <tt class="docutils literal"><span class="pre">reverse_iterator</span></tt>.</p>
 <pre class="literal-block">
 char letters_[] = &quot;hello world!&quot;;
 const int N = sizeof(letters_)/sizeof(char) - 1;
@@ -270,7 +272,7 @@ sequence in double-reversed (normal) order:     hello world!
 <p>The source code for this example can be found <a class="reference" href="../example/reverse_iterator_example.cpp">here</a>.</p>
 </div>
 </div>
-<hr class="footer" />
+<hr class="docutils footer" />
 <div class="footer">
 <a class="reference" href="reverse_iterator.rst">View document source</a>.
 Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.

doc/reverse_iterator.rst

@@ -8,7 +8,7 @@
                Lab`_, University of Hanover `Institute for Transport
                Railway Operation and Construction`_
 :date: $Date$
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
+:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. 
 
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. _`Open Systems Lab`: http://www.osl.iu.edu

doc/reverse_iterator_ref.rst

@@ -40,7 +40,9 @@ convertible to ``input_iterator_tag``.
 ``reverse_iterator`` requirements
 .................................
 
-``Iterator`` must be a model of Bidirectional Traversal Iterator.
+``Iterator`` must be a model of Bidirectional Traversal Iterator.  The
+type ``iterator_traits<Iterator>::reference`` must be the type of
+``*i``, where ``i`` is an object of type ``Iterator``.
 
 
 

doc/rst2html

@@ -1,7 +1,7 @@
 #!/bin/sh
 PYTHONPATH="c:/src/docutils/docutils;c:/src/docutils/docutils/extras"
 export PYTHONPATH
-python c:/src/docutils/docutils/tools/html.py -gs $1 `echo $1 | sed 's/\(.*\)\..*/\1.html/'`
+python c:/src/docutils/docutils/tools/rst2html.py -gs $1 `echo $1 | sed 's/\(.*\)\..*/\1.html/'`
 
 
 

doc/rst2latex

@@ -0,0 +1,4 @@
+#!/bin/sh
+PYTHONPATH="c:/src/docutils/docutils;c:/src/docutils/docutils/extras"
+export PYTHONPATH
+python c:/src/docutils/docutils/tools/rst2latex.py --documentoptions pdftex --stylesheet=docutils.sty $1 `echo $1 | sed 's/\(.*\)\..*/\1.tex/'`

doc/sources.py

@@ -1,6 +1,6 @@
-# This is where we list the ReStructuredText source files that form
-# the book.  When you're ready to expose a new chapter, add the
-# filename here and put links in index.rst
+# 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)
 
 sources = [
 'counting_iterator.rst',
@@ -14,6 +14,11 @@ sources = [
 'iterator_facade.rst',
 'new-iter-concepts.rst',
 'permutation_iterator.rst',
-'reverse_iterator.rst'
+'reverse_iterator.rst',
+'transform_iterator.rst',
+'zip_iterator.rst',
+'iterator_archetypes.rst',
+'iterator_concepts.rst',
+'iterator_traits.rst'
       ]
 

doc/style.tex

@@ -1,41 +0,0 @@
-% donot indent first line.
-\setlength{\parindent}{0pt}
-\setlength{\parskip}{5pt plus 2pt minus 1pt}
-
-% sloppy
-% ------
-% Less strict (opposite to default fussy) space size between words. Therefore
-% less hyphenation.
-\sloppy
-
-% fonts
-% -----
-% times for pdf generation, gives smaller pdf files.
-%
-% But in standard postscript fonts: courier and times/helvetica do not fit.
-% Maybe use pslatex.
-\usepackage{times} 
-\usepackage{pslatex} 
-
-% pagestyle
-% \usepackage{fancyhdr}
-\pagestyle{headings}
-\setlength{\paperwidth}{8.5in}
-\setlength{\paperheight}{11in}
-
-\setlength{\oddsidemargin}{0.375in}
-\setlength{\evensidemargin}{0.375in}
-\setlength{\textwidth}{6.125in}
-\setlength{\textheight}{8.875in}
-
-\setlength{\topmargin}{-0.375in}
-\setlength{\headheight}{0.25in}
-\setlength{\headsep}{0.25in}
-\setlength{\footskip}{0.25in}
-
-\setlength{\admonitionwidth}{0.9\textwidth}
-\setlength{\docinfowidth}{0.9\textwidth}
-
-
-
-