Renamed remotely

[SVN r38365]

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

@@ -1,71 +0,0 @@
-<?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.1: http://docutils.sourceforge.net/" />
-<title>Bidirectional Traversal Concept</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="bidirectional-traversal-concept">
-<h1 class="title">Bidirectional Traversal Concept</h1>
-<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 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

@@ -1,37 +0,0 @@
-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

@@ -1,62 +0,0 @@
-<?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.1: http://docutils.sourceforge.net/" />
-<title>Forward Traversal Concept</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="forward-traversal-concept">
-<h1 class="title">Forward Traversal Concept</h1>
-<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 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

@@ -1,27 +0,0 @@
-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,15 +1,232 @@
-# 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)
+# GNUmakefile for postprocessing PDF files
+#
+# <EFBFBD> 2000 IBM Corporation.
+# Licensed under the GNU GPL.
 
+########################################################################
+# 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
 
-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 & postprocessors
+PPOWER4	      = ppower4
+PDFLATEX      = pdflatex
+METAPOST      = mpost
+FIG2DEV	      = fig2dev
+BIBTEX	      = bibtex
+FOLIAGECUTTER = foliageCutter --verbose
+RST2LATEX	  = rst2latex
+RST2HTML	  = rst2html
 
+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

@@ -1,61 +0,0 @@
-<?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.1: http://docutils.sourceforge.net/" />
-<title>Incrementable Iterator Concept</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="incrementable-iterator-concept">
-<h1 class="title">Incrementable Iterator Concept</h1>
-<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 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

@@ -1,28 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,51 +0,0 @@
-<?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.1: http://docutils.sourceforge.net/" />
-<title>Lvalue Iterator Concept</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="lvalue-iterator-concept">
-<h1 class="title">Lvalue Iterator Concept</h1>
-<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 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

@@ -1,21 +0,0 @@
-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

@@ -1,129 +0,0 @@
-<?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.1: http://docutils.sourceforge.net/" />
-<title>Random Access Traversal Concept</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="random-access-traversal-concept">
-<h1 class="title">Random Access Traversal Concept</h1>
-<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 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

@@ -1,63 +0,0 @@
-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

@@ -1,59 +0,0 @@
-<?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.1: http://docutils.sourceforge.net/" />
-<title>Readable Iterator Concept</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="readable-iterator-concept">
-<h1 class="title">Readable Iterator Concept</h1>
-<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 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

@@ -1,23 +0,0 @@
-
-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

@@ -1,63 +0,0 @@
-<?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.1: http://docutils.sourceforge.net/" />
-<title>Single Pass Iterator Concept</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="single-pass-iterator-concept">
-<h1 class="title">Single Pass Iterator Concept</h1>
-<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 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

@@ -1,28 +0,0 @@
-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

@@ -1,49 +0,0 @@
-<?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.1: http://docutils.sourceforge.net/" />
-<title>Swappable Iterator Concept</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="swappable-iterator-concept">
-<h1 class="title">Swappable Iterator Concept</h1>
-<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 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

@@ -1,19 +0,0 @@
-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

@@ -1,47 +0,0 @@
-<?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.1: http://docutils.sourceforge.net/" />
-<title>Writable Iterator Concept</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="writable-iterator-concept">
-<h1 class="title">Writable Iterator Concept</h1>
-<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 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

@@ -1,17 +0,0 @@
-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

@@ -1,285 +0,0 @@
-<?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.1: 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" />
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="counting-iterator">
-<h1 class="title">Counting Iterator</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;ive.uni-hannover.de">witt&#64;ive.uni-hannover.de</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>, 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>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
-</tbody>
-</table>
-<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">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
-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.
-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
-returns the current value of the object. All other iterator operations
-are forwarded to the adapted object.</p>
-</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>
-<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="#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>
-<pre class="literal-block">
-template &lt;
-    class Incrementable
-  , class CategoryOrTraversal = use_default
-  , class Difference = use_default
-&gt;
-class counting_iterator
-{
-public:
-    typedef Incrementable value_type;
-    typedef const Incrementable&amp; reference;
-    typedef const Incrementable* pointer;
-    typedef /* see below */ difference_type;
-    typedef /* see below */ iterator_category;
-
-    counting_iterator();
-    counting_iterator(counting_iterator const&amp; rhs);
-    explicit counting_iterator(Incrementable x);
-    Incrementable const&amp; base() const;
-    reference operator*() const;
-    counting_iterator&amp; operator++();
-    counting_iterator&amp; operator--();
-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
-algorithm:</p>
-<pre class="literal-block">
-if (CategoryOrTraversal is not use_default)
-    return CategoryOrTraversal
-else if (numeric_limits&lt;Incrementable&gt;::is_specialized)
-    return <a class="reference" href="iterator_facade.html#iterator-category"><em>iterator-category</em></a>(
-        random_access_traversal_tag, Incrementable, const Incrementable&amp;)
-else
-    return <a class="reference" href="iterator_facade.html#iterator-category"><em>iterator-category</em></a>(
-         iterator_traversal&lt;Incrementable&gt;::type, 
-         Incrementable, const Incrementable&amp;)
-</pre>
-<dl>
-<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>
-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>
-<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>,
-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>,
-the following must must also be valid:</p>
-<pre class="literal-block">
-counting_iterator::difference_type n;
-i += n;
-n = i - j;
-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
-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>
-</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>
-<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
-operations.</p>
-<p><tt class="literal"><span class="pre">counting_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">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>
-</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">
-<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>
-</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">
-<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>
-</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_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">
-<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>
-<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">counting_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_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>
-</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">
-<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>
-</tbody>
-</table>
-<pre class="literal-block">
-template &lt;class Incrementable&gt;
-counting_iterator&lt;Incrementable&gt; make_counting_iterator(Incrementable x);
-</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">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>
-</tbody>
-</table>
-</div>
-<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
-into the first array via indirection through the second array.</p>
-<pre class="literal-block">
-int N = 7;
-std::vector&lt;int&gt; numbers;
-typedef std::vector&lt;int&gt;::iterator n_iter;
-std::copy(boost::counting_iterator&lt;int&gt;(0),
-         boost::counting_iterator&lt;int&gt;(N),
-         std::back_inserter(numbers));
-
-std::vector&lt;std::vector&lt;int&gt;::iterator&gt; pointers;
-std::copy(boost::make_counting_iterator(numbers.begin()),
-          boost::make_counting_iterator(numbers.end()),
-          std::back_inserter(pointers));
-
-std::cout &lt;&lt; &quot;indirectly printing out the numbers from 0 to &quot; 
-          &lt;&lt; N &lt;&lt; std::endl;
-std::copy(boost::make_indirect_iterator(pointers.begin()),
-          boost::make_indirect_iterator(pointers.end()),
-          std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
-std::cout &lt;&lt; std::endl;
-</pre>
-<p>The output is:</p>
-<pre class="literal-block">
-indirectly printing out the numbers from 0 to 7
-0 1 2 3 4 5 6 
-</pre>
-<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="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

@@ -1,39 +0,0 @@
-+++++++++++++++++++
- Counting Iterator
-+++++++++++++++++++
-
-:Author: David Abrahams, Jeremy Siek, Thomas Witt
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@ive.uni-hannover.de
-:organization: `Boost Consulting`_, Indiana University `Open Systems
-               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
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-.. _`Open Systems Lab`: http://www.osl.iu.edu
-.. _`Institute for Transport Railway Operation and Construction`: http://www.ive.uni-hannover.de
-
-:abstract: How would you fill up a vector with the numbers zero
-  through one hundred using ``std::copy()``?  The only iterator
-  operation missing from builtin integer types is an
-  ``operator*()`` 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.
-
-  .. include:: counting_iterator_abstract.rst
-
-.. contents:: Table of Contents
-
-``counting_iterator`` synopsis
-..............................
-
-.. include:: counting_iterator_ref.rst
-.. include:: make_counting_iterator.rst
-
-.. include:: counting_iterator_eg.rst
-
-.. _iterator-category: iterator_facade.html#iterator-category
-.. |iterator-category| replace:: *iterator-category*

doc/counting_iterator_abstract.rst

@@ -1,4 +0,0 @@
-``counting_iterator`` adapts an object by adding an ``operator*`` that
-returns the current value of the object. All other iterator operations
-are forwarded to the adapted object.
-

doc/counting_iterator_eg.rst

@@ -1,40 +0,0 @@
-
-Example
-.......
-
-This example fills an array with numbers and a second array with
-pointers into the first array, using ``counting_iterator`` for both
-tasks. Finally ``indirect_iterator`` is used to print out the numbers
-into the first array via indirection through the second array.
-
-::
-
-    int N = 7;
-    std::vector<int> numbers;
-    typedef std::vector<int>::iterator n_iter;
-    std::copy(boost::counting_iterator<int>(0),
-             boost::counting_iterator<int>(N),
-             std::back_inserter(numbers));
-
-    std::vector<std::vector<int>::iterator> pointers;
-    std::copy(boost::make_counting_iterator(numbers.begin()),
-	      boost::make_counting_iterator(numbers.end()),
-	      std::back_inserter(pointers));
-
-    std::cout << "indirectly printing out the numbers from 0 to " 
-	      << N << std::endl;
-    std::copy(boost::make_indirect_iterator(pointers.begin()),
-	      boost::make_indirect_iterator(pointers.end()),
-	      std::ostream_iterator<int>(std::cout, " "));
-    std::cout << std::endl;
-
-
-The output is::
-
-    indirectly printing out the numbers from 0 to 7
-    0 1 2 3 4 5 6 
-
-The source code for this example can be found `here`__.
-
-__ ../example/counting_iterator_example.cpp
-

doc/counting_iterator_ref.rst

@@ -1,145 +0,0 @@
-::
-
-  template <
-      class Incrementable
-    , class CategoryOrTraversal = use_default
-    , class Difference = use_default
-  >
-  class counting_iterator
-  {
-  public:
-      typedef Incrementable value_type;
-      typedef const Incrementable& reference;
-      typedef const Incrementable* pointer;
-      typedef /* see below */ difference_type;
-      typedef /* see below */ iterator_category;
-
-      counting_iterator();
-      counting_iterator(counting_iterator const& rhs);
-      explicit counting_iterator(Incrementable x);
-      Incrementable const& base() const;
-      reference operator*() const;
-      counting_iterator& operator++();
-      counting_iterator& operator--();
-  private:
-      Incrementable m_inc; // exposition
-  };
-
-
-If the ``Difference`` argument is ``use_default`` then
-``difference_type`` is an unspecified signed integral
-type. Otherwise ``difference_type`` is ``Difference``.
-
-``iterator_category`` is determined according to the following
-algorithm:
-
-.. parsed-literal::
-
-   if (CategoryOrTraversal is not use_default)
-       return CategoryOrTraversal
-   else if (numeric_limits<Incrementable>::is_specialized)
-       return |iterator-category|_\ (
-           random_access_traversal_tag, Incrementable, const Incrementable&)
-   else
-       return |iterator-category|_\ (
-            iterator_traversal<Incrementable>::type, 
-            Incrementable, const Incrementable&)
-        
-[*Note:* implementers are encouraged to provide an implementation of
-  ``operator-`` and a ``difference_type`` that avoids overflows in
-  the cases where ``std::numeric_limits<Incrementable>::is_specialized``
-  is true.]
-
-``counting_iterator`` requirements
-..................................
-
-The ``Incrementable`` argument shall be Copy Constructible and Assignable.
-
-If ``iterator_category`` is convertible to ``forward_iterator_tag``
-or ``forward_traversal_tag``, the following must be well-formed::
-
-    Incrementable i, j;
-    ++i;         // pre-increment
-    i == j;      // operator equal
-
-
-If ``iterator_category`` is convertible to
-``bidirectional_iterator_tag`` or ``bidirectional_traversal_tag``,
-the following expression must also be well-formed::
-
-    --i
-
-If ``iterator_category`` is convertible to
-``random_access_iterator_tag`` or ``random_access_traversal_tag``,
-the following must must also be valid::
-
-    counting_iterator::difference_type n;
-    i += n;
-    n = i - j;
-    i < j;
-
-``counting_iterator`` models
-............................
-
-Specializations of ``counting_iterator`` model Readable Lvalue
-Iterator. In addition, they model the concepts corresponding to the
-iterator tags to which their ``iterator_category`` is convertible.
-Also, if ``CategoryOrTraversal`` is not ``use_default`` then
-``counting_iterator`` models the concept corresponding to the iterator
-tag ``CategoryOrTraversal``.  Otherwise, if
-``numeric_limits<Incrementable>::is_specialized``, then
-``counting_iterator`` models Random Access Traversal Iterator.
-Otherwise, ``counting_iterator`` models the same iterator traversal
-concepts modeled by ``Incrementable``.
-
-``counting_iterator<X,C1,D1>`` is interoperable with
-``counting_iterator<Y,C2,D2>`` if and only if ``X`` is
-interoperable with ``Y``.
-
-
-
-``counting_iterator`` operations
-................................
-
-In addition to the operations required by the concepts modeled by
-``counting_iterator``, ``counting_iterator`` provides the following
-operations.
-
-
-``counting_iterator();``
-
-:Requires: ``Incrementable`` is Default Constructible.
-:Effects: Default construct the member ``m_inc``.
-
-
-``counting_iterator(counting_iterator const& rhs);``
-
-:Effects: Construct member ``m_inc`` from ``rhs.m_inc``.
-
-
-
-``explicit counting_iterator(Incrementable x);``
-
-:Effects: Construct member ``m_inc`` from ``x``.
-
-
-``reference operator*() const;``
-
-:Returns: ``m_inc``
-
-
-``counting_iterator& operator++();``
-
-:Effects: ``++m_inc``
-:Returns: ``*this``
-
-
-``counting_iterator& operator--();``
-
-:Effects: ``--m_inc``
-:Returns: ``*this``  
-
-
-``Incrementable const& base() const;``
-
-:Returns: ``m_inc``

doc/default.css

@@ -1,224 +0,0 @@
-/*
-:Author: David Goodger
-:Contact: goodger@users.sourceforge.net
-:date: $Date$
-:version: $Revision$
-:copyright: This stylesheet has been placed in the public domain.
-
-Default cascading style sheet for the HTML output of Docutils.
-*/
-
-.first {
-  margin-top: 0 }
-
-.last {
-  margin-bottom: 0 }
-
-a.toc-backref {
-  text-decoration: none ;
-  color: black }
-
-dd {
-  margin-bottom: 0.5em }
-
-div.abstract {
-  margin: 2em 5em }
-
-div.abstract p.topic-title {
-  font-weight: bold ;
-  text-align: center }
-
-div.attention, div.caution, div.danger, div.error, div.hint,
-div.important, div.note, div.tip, div.warning, div.admonition {
-  margin: 2em ;
-  border: medium outset ;
-  padding: 1em }
-
-div.attention p.admonition-title, div.caution p.admonition-title,
-div.danger p.admonition-title, div.error p.admonition-title,
-div.warning p.admonition-title {
-  color: red ;
-  font-weight: bold ;
-  font-family: sans-serif }
-
-div.hint p.admonition-title, div.important p.admonition-title,
-div.note p.admonition-title, div.tip p.admonition-title,
-div.admonition p.admonition-title {
-  font-weight: bold ;
-  font-family: sans-serif }
-
-div.dedication {
-  margin: 2em 5em ;
-  text-align: center ;
-  font-style: italic }
-
-div.dedication p.topic-title {
-  font-weight: bold ;
-  font-style: normal }
-
-div.figure {
-  margin-left: 2em }
-
-div.footer, div.header {
-  font-size: smaller }
-
-div.sidebar {
-  margin-left: 1em ;
-  border: medium outset ;
-  padding: 0em 1em ;
-  background-color: #ffffee ;
-  width: 40% ;
-  float: right ;
-  clear: right }
-
-div.sidebar p.rubric {
-  font-family: sans-serif ;
-  font-size: medium }
-
-div.system-messages {
-  margin: 5em }
-
-div.system-messages h1 {
-  color: red }
-
-div.system-message {
-  border: medium outset ;
-  padding: 1em }
-
-div.system-message p.system-message-title {
-  color: red ;
-  font-weight: bold }
-
-div.topic {
-  margin: 2em }
-
-h1.title {
-  text-align: center }
-
-h2.subtitle {
-  text-align: center }
-
-hr {
-  width: 75% }
-
-ol.simple, ul.simple {
-  margin-bottom: 1em }
-
-ol.arabic {
-  list-style: decimal }
-
-ol.loweralpha {
-  list-style: lower-alpha }
-
-ol.upperalpha {
-  list-style: upper-alpha }
-
-ol.lowerroman {
-  list-style: lower-roman }
-
-ol.upperroman {
-  list-style: upper-roman }
-
-p.attribution {
-  text-align: right ;
-  margin-left: 50% }
-
-p.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-p.rubric {
-  font-weight: bold ;
-  font-size: larger ;
-  color: maroon ;
-  text-align: center }
-
-p.sidebar-title {
-  font-family: sans-serif ;
-  font-weight: bold ;
-  font-size: larger }
-
-p.sidebar-subtitle {
-  font-family: sans-serif ;
-  font-weight: bold }
-
-p.topic-title {
-  font-weight: bold }
-
-pre.address {
-  margin-bottom: 0 ;
-  margin-top: 0 ;
-  font-family: serif ;
-  font-size: 100% }
-
-pre.line-block {
-  font-family: serif ;
-  font-size: 100% }
-
-pre.literal-block, pre.doctest-block {
-  margin-left: 2em ;
-  margin-right: 2em ;
-  background-color: #eeeeee }
-
-span.classifier {
-  font-family: sans-serif ;
-  font-style: oblique }
-
-span.classifier-delimiter {
-  font-family: sans-serif ;
-  font-weight: bold }
-
-span.interpreted {
-  font-family: sans-serif }
-
-span.option {
-  white-space: nowrap }
-
-span.option-argument {
-  font-style: italic }
-
-span.pre {
-  white-space: pre }
-
-span.problematic {
-  color: red }
-
-table {
-  margin-top: 0.5em ;
-  margin-bottom: 0.5em }
-
-table.citation {
-  border-left: solid thin gray ;
-  padding-left: 0.5ex }
-
-table.docinfo {
-  margin: 2em 4em }
-
-table.footnote {
-  border-left: solid thin black ;
-  padding-left: 0.5ex }
-
-td, th {
-  padding-left: 0.5em ;
-  padding-right: 0.5em ;
-  vertical-align: top }
-
-th.docinfo-name, th.field-name {
-  font-weight: bold ;
-  text-align: left ;
-  white-space: nowrap }
-
-h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt {
-  font-size: 100% }
-
-tt {
-  background-color: #eeeeee }
-
-ul.auto-toc {
-  list-style-type: none }

doc/docutils.sty

@@ -1,54 +0,0 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%% 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.diff

@@ -1,228 +0,0 @@
-Index: facade-and-adaptor.rst
-===================================================================
-RCS file: /cvsroot/boost/boost/libs/iterator/doc/facade-and-adaptor.rst,v
-retrieving revision 1.9
-retrieving revision 1.14
-diff -b -d -u -r1.9 -r1.14
---- facade-and-adaptor.rst	22 Sep 2003 19:55:00 -0000	1.9
-+++ facade-and-adaptor.rst	18 Jan 2004 15:51:06 -0000	1.14
-@@ -3,17 +3,25 @@  None
- +++++++++++++++++++++++++++++
- 
- :Author: David Abrahams, Jeremy Siek, Thomas Witt
--:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@acm.org
-+:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
- :organization: `Boost Consulting`_, Indiana University `Open Systems
--               Lab`_, University of Hanover `Institute for Transport
--               Railway Operation and Construction`_
--:date: $Date: 2004/01/18 19:56:39 $
--:Number: N1530=03-0113
-+               Lab`_, `Zephyr Associates, Inc.`_
-+:date: $Date: 2004/01/18 19:56:39 $
-+
-+:Number: This is a revised version of N1530_\ =03-0113, which was
-+         accepted for Technical Report 1 by the C++ standard
-+         committee's library working group.  
-+
-+.. Version 1.9 of this ReStructuredText document corresponds to
-+   n1530_, the paper accepted by the LWG.
-+
-+.. _n1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
-+
- :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
- 
- .. _`Boost Consulting`: http://www.boost-consulting.com
- .. _`Open Systems Lab`: http://www.osl.iu.edu
--.. _`Institute for Transport Railway Operation and Construction`: http://www.ive.uni-hannover.de
-+.. _`Zephyr Associates, Inc.`: http://www.styleadvisor.com
- 
- :abstract: We propose a set of class templates that help programmers
-            build standard-conforming iterators, both from scratch and
-@@ -124,15 +132,15 @@  None
- =================
- 
- This proposal is formulated in terms of the new ``iterator concepts``
--as proposed in `n1477`_, since user-defined and especially adapted
-+as proposed in n1550_, since user-defined and especially adapted
- iterators suffer from the well known categorization problems that are
- inherent to the current iterator categories.
- 
--.. _`n1477`: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1477.html
-+.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
- 
--This proposal does not strictly depend on proposal `n1477`_, as there
-+This proposal does not strictly depend on proposal n1550_, as there
- is a direct mapping between new and old categories. This proposal
--could be reformulated using this mapping if `n1477`_ was not accepted.
-+could be reformulated using this mapping if n1550_ was not accepted.
- 
- Interoperability
- ================
-@@ -141,24 +149,24 @@  None
- current standard.  There are currently two defect reports that are
- concerned with interoperability issues.
- 
--Issue `179`_ concerns the fact that mutable container iterator types
-+Issue 179_ concerns the fact that mutable container iterator types
- are only required to be convertible to the corresponding constant
- iterator types, but objects of these types are not required to
- interoperate in comparison or subtraction expressions.  This situation
- is tedious in practice and out of line with the way built in types
- work.  This proposal implements the proposed resolution to issue
--`179`_, as most standard library implementations do nowadays. In other
-+179_, as most standard library implementations do nowadays. In other
- words, if an iterator type A has an implicit or user defined
- conversion to an iterator type B, the iterator types are interoperable
- and the usual set of operators are available.
- 
--Issue `280`_ concerns the current lack of interoperability between
-+Issue 280_ concerns the current lack of interoperability between
- reverse iterator types. The proposed new reverse_iterator template
- fixes the issues raised in 280. It provides the desired
- interoperability without introducing unwanted overloads.
- 
--.. _`179`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179
--.. _`280`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280
-+.. _179: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179
-+.. _280: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280
- 
- 
- Iterator Facade
-@@ -195,7 +203,7 @@  None
- * ``filter_iterator``, which provides a view of an iterator range in
-   which some elements of the underlying range are skipped.
- 
--.. _counting_iterator:
-+.. _counting: 
- 
- * ``counting_iterator``, which adapts any incrementable type
-   (e.g. integers, iterators) so that incrementing/decrementing the
-@@ -226,15 +234,13 @@  Issue 9.1 et al
- ::
- 
-   struct use_default;
--  const unsigned use_default_access = -1;
-        
-   struct iterator_core_access { /* implementation detail */ };
-   
-   template <
-       class Derived
-     , class Value
--    , unsigned AccessCategory
--    , class TraversalCategory
-+    , class CategoryOrTraversal
-     , class Reference  = Value&
-     , class Difference = ptrdiff_t
-   >
-@@ -244,8 +250,7 @@  Issue 9.1 et al.
-       class Derived
-     , class Base
-     , class Value      = use_default
--    , unsigned Access  = use_default_access
--    , class Traversal  = use_default
-+    , class CategoryOrTraversal  = use_default
-     , class Reference  = use_default
-     , class Difference = use_default
-   >
-@@ -254,10 +259,9 @@  Issue 9.1 et al.
-   template <
-       class Iterator
-     , class Value = use_default
--    , unsigned Access  = use_default_access
--    , class Traversal  = use_default
-+    , class CategoryOrTraversal = use_default
-     , class Reference = use_default
-     , class Difference = use_default
-   >
-   class indirect_iterator;
-   
-Issue 9.44y
-
-+  template <class Dereferenceable>
-+  struct pointee;
-+
-+  template <class Dereferenceable>
-+  struct indirect_reference;
-+
-   template <class Iterator>
-   class reverse_iterator;
- 
-@@ -277,8 +287,7 @@  Issue 9.1 et al.
- 
-   template <
-       class Incrementable
--    , unsigned Access  = use_default_access
--    , class Traversal  = use_default
-+    , class CategoryOrTraversal  = use_default
-     , class Difference = use_default
-   >
-   class counting_iterator
-@@ -312,17 +321,35 @@  Issue 9.8
- Specialized adaptors [lib.iterator.special.adaptors]
- ====================================================
- 
--.. The requirements for all of these need to be written *much* more
--   formally -DWA
--
- 
--[*Note:* The ``enable_if_convertible<X,Y>::type`` expression used in
-+The ``enable_if_convertible<X,Y>::type`` expression used in
- this section is for exposition purposes. The converting constructors
- for specialized adaptors should be only be in an overload set provided
- that an object of type ``X`` is implicitly convertible to an object of
--type ``Y``.  The ``enable_if_convertible`` approach uses SFINAE to
-+type ``Y``.  
-+The signatures involving ``enable_if_convertible`` should behave
-+*as-if* ``enable_if_convertible`` were defined to be::
-+
-+  template <bool> enable_if_convertible_impl
-+  {};
-+
-+  template <> enable_if_convertible_impl<true>
-+  { struct type; };
-+
-+  template<typename From, typename To>
-+  struct enable_if_convertible
-+    : enable_if_convertible_impl<is_convertible<From,To>::value>
-+  {};
-+
-+If an expression other than the default argument is used to supply
-+the value of a function parameter whose type is written in terms
-+of ``enable_if_convertible``, the program is ill-formed, no
-+diagnostic required.
-+
-+[*Note:* The ``enable_if_convertible`` approach uses SFINAE to
- take the constructor out of the overload set when the types are not
--implicitly convertible.]
-+implicitly convertible.  
-+]
- 
- 
- Indirect iterator
-@@ -330,6 +357,16 @@  Issue 9.44y
- 
- .. include:: indirect_iterator_abstract.rst
- 
-+Class template ``pointee``
-+....................................
-+
-+.. include:: pointee_ref.rst
-+
-+Class template ``indirect_reference``
-+.....................................
-+
-+.. include:: indirect_reference_ref.rst
-+
- Class template ``indirect_iterator``
- ....................................
- 
-@@ -393,8 +430,7 @@
- 
- 
- 
--..
-- LocalWords:  Abrahams Siek Witt istream ostream iter MTL strided interoperate
-+.. LocalWords:  Abrahams Siek Witt istream ostream iter MTL strided interoperate
-  LocalWords:  CRTP metafunctions inlining lvalue JGS incrementable BGL LEDA cv
-  LocalWords:  GraphBase struct ptrdiff UnaryFunction const int typename bool pp
-  LocalWords:  lhs rhs SFINAE markup iff tmp OtherDerived OtherIterator DWA foo

doc/facade-and-adaptor.rst

@@ -1,434 +0,0 @@
-+++++++++++++++++++++++++++++
- Iterator Facade and Adaptor
-+++++++++++++++++++++++++++++
-
-: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$
-
-:Number: This is a revised version of N1530_\ =03-0113, which was
-         accepted for Technical Report 1 by the C++ standard
-         committee's library working group.  
-
-.. Version 1.9 of this ReStructuredText document corresponds to
-   n1530_, the paper accepted by the LWG.
-
-.. _n1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
-
-:copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-.. _`Open Systems Lab`: http://www.osl.iu.edu
-.. _`Zephyr Associates, Inc.`: http://www.styleadvisor.com
-
-:abstract: We propose a set of class templates that help programmers
-           build standard-conforming iterators, both from scratch and
-           by adapting other iterators.
-
-.. contents:: Table of Contents
-
-============
- Motivation
-============
-
-Iterators play an important role in modern C++ programming. The
-iterator is the central abstraction of the algorithms of the Standard
-Library, allowing algorithms to be re-used in in a wide variety of
-contexts.  The C++ Standard Library contains a wide variety of useful
-iterators. Every one of the standard containers comes with constant
-and mutable iterators [#mutable]_, and also reverse versions of those
-same iterators which traverse the container in the opposite direction.
-The Standard also supplies ``istream_iterator`` and
-``ostream_iterator`` for reading from and writing to streams,
-``insert_iterator``, ``front_insert_iterator`` and
-``back_insert_iterator`` for inserting elements into containers, and
-``raw_storage_iterator`` for initializing raw memory [7].
-
-Despite the many iterators supplied by the Standard Library, obvious
-and useful iterators are missing, and creating new iterator types is
-still a common task for C++ programmers.  The literature documents
-several of these, for example line_iterator [3] and Constant_iterator
-[9].  The iterator abstraction is so powerful that we expect
-programmers will always need to invent new iterator types.
-
-Although it is easy to create iterators that *almost* conform to the
-standard, the iterator requirements contain subtleties which can make
-creating an iterator which *actually* conforms quite difficult.
-Further, the iterator interface is rich, containing many operators
-that are technically redundant and tedious to implement.  To automate
-the repetitive work of constructing iterators, we propose
-``iterator_facade``, an iterator base class template which provides
-the rich interface of standard iterators and delegates its
-implementation to member functions of the derived class.  In addition
-to reducing the amount of code necessary to create an iterator, the
-``iterator_facade`` also provides compile-time error detection.
-Iterator implementation mistakes that often go unnoticed are turned
-into compile-time errors because the derived class implementation must
-match the expectations of the ``iterator_facade``.
-
-A common pattern of iterator construction is the adaptation of one
-iterator to form a new one.  The functionality of an iterator is
-composed of four orthogonal aspects: traversal, indirection, equality
-comparison and distance measurement.  Adapting an old iterator to
-create a new one often saves work because one can reuse one aspect of
-functionality while redefining the other.  For example, the Standard
-provides ``reverse_iterator``, which adapts any Bidirectional Iterator
-by inverting its direction of traversal.  As with plain iterators,
-iterator adaptors defined outside the Standard have become commonplace
-in the literature:
-
-* Checked iter[13] adds bounds-checking to an existing iterator.
-
-* The iterators of the View Template Library[14], which adapts
-  containers, are themselves adaptors over the underlying iterators.
-
-* Smart iterators [5] adapt an iterator's dereferencing behavior by
-  applying a function object to the object being referenced and
-  returning the result.
-
-* Custom iterators [4], in which a variety of adaptor types are enumerated.
-
-* Compound iterators [1], which access a slice out of a container of containers.
-
-* Several iterator adaptors from the MTL [12].  The MTL contains a
-  strided iterator, where each call to ``operator++()`` moves the
-  iterator ahead by some constant factor, and a scaled iterator, which
-  multiplies the dereferenced value by some constant.
-
-.. [#concept] We use the term concept to mean a set of requirements
-   that a type must satisfy to be used with a particular template
-   parameter.
-
-.. [#mutable] The term mutable iterator refers to iterators over objects that
-   can be changed by assigning to the dereferenced iterator, while
-   constant iterator refers to iterators over objects that cannot be
-   modified.
-
-To fulfill the need for constructing adaptors, we propose the
-``iterator_adaptor`` class template.  Instantiations of
-``iterator_adaptor`` serve as a base classes for new iterators,
-providing the default behavior of forwarding all operations to the
-underlying iterator.  The user can selectively replace these features
-in the derived iterator class.  This proposal also includes a number
-of more specialized adaptors, such as the ``transform_iterator`` that
-applies some user-specified function during the dereference of the
-iterator.
-
-========================
- Impact on the Standard
-========================
-
-This proposal is purely an addition to the C++ standard library.
-However, note that this proposal relies on the proposal for New
-Iterator Concepts.
-
-========
- Design
-========
-
-Iterator Concepts
-=================
-
-This proposal is formulated in terms of the new ``iterator concepts``
-as proposed in n1550_, since user-defined and especially adapted
-iterators suffer from the well known categorization problems that are
-inherent to the current iterator categories.
-
-.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
-
-This proposal does not strictly depend on proposal n1550_, as there
-is a direct mapping between new and old categories. This proposal
-could be reformulated using this mapping if n1550_ was not accepted.
-
-Interoperability
-================
-
-The question of iterator interoperability is poorly addressed in the
-current standard.  There are currently two defect reports that are
-concerned with interoperability issues.
-
-Issue 179_ concerns the fact that mutable container iterator types
-are only required to be convertible to the corresponding constant
-iterator types, but objects of these types are not required to
-interoperate in comparison or subtraction expressions.  This situation
-is tedious in practice and out of line with the way built in types
-work.  This proposal implements the proposed resolution to issue
-179_, as most standard library implementations do nowadays. In other
-words, if an iterator type A has an implicit or user defined
-conversion to an iterator type B, the iterator types are interoperable
-and the usual set of operators are available.
-
-Issue 280_ concerns the current lack of interoperability between
-reverse iterator types. The proposed new reverse_iterator template
-fixes the issues raised in 280. It provides the desired
-interoperability without introducing unwanted overloads.
-
-.. _179: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179
-.. _280: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280
-
-
-Iterator Facade
-===============
-
-.. include:: iterator_facade_body.rst
-
-Iterator Adaptor
-================
-
-.. include:: iterator_adaptor_body.rst
-
-Specialized Adaptors
-====================
-
-This proposal also contains several examples of specialized adaptors
-which were easily implemented using ``iterator_adaptor``:
-
-* ``indirect_iterator``, which iterates over iterators, pointers,
-  or smart pointers and applies an extra level of dereferencing.
-
-* A new ``reverse_iterator``, which inverts the direction of a Base
-  iterator's motion, while allowing adapted constant and mutable
-  iterators to interact in the expected ways (unlike those in most
-  implementations of C++98).
-
-* ``transform_iterator``, which applies a user-defined function object
-  to the underlying values when dereferenced.
-
-* ``filter_iterator``, which provides a view of an iterator range in
-  which some elements of the underlying range are skipped.
-
-.. _counting: 
-
-* ``counting_iterator``, which adapts any incrementable type
-  (e.g. integers, iterators) so that incrementing/decrementing the
-  adapted iterator and dereferencing it produces successive values of
-  the Base type.
-
-* ``function_output_iterator``, which makes it easier to create custom
-  output iterators.
-
-Based on examples in the Boost library, users have generated many new
-adaptors, among them a permutation adaptor which applies some
-permutation to a random access iterator, and a strided adaptor, which
-adapts a random access iterator by multiplying its unit of motion by a
-constant factor.  In addition, the Boost Graph Library (BGL) uses
-iterator adaptors to adapt other graph libraries, such as LEDA [10]
-and Stanford GraphBase [8], to the BGL interface (which requires C++
-Standard compliant iterators).
-
-===============
- Proposed Text
-===============
-
-
-Header ``<iterator_helper>`` synopsis    [lib.iterator.helper.synopsis]
-=======================================================================
-
-
-::
-
-  struct use_default;
-
-  struct iterator_core_access { /* implementation detail */ };
-  
-  template <
-      class Derived
-    , class Value
-    , class CategoryOrTraversal
-    , class Reference  = Value&
-    , class Difference = ptrdiff_t
-  >
-  class iterator_facade;
-
-  template <
-      class Derived
-    , class Base
-    , class Value      = use_default
-    , class CategoryOrTraversal  = use_default
-    , class Reference  = use_default
-    , class Difference = use_default
-  >
-  class iterator_adaptor;
-  
-  template <
-      class Iterator
-    , class Value = use_default
-    , class CategoryOrTraversal = use_default
-    , class Reference = use_default
-    , class Difference = use_default
-  >
-  class indirect_iterator;
-  
-  template <class Dereferenceable>
-  struct pointee;
-
-  template <class Dereferenceable>
-  struct indirect_reference;
-
-  template <class Iterator>
-  class reverse_iterator;
-
-  template <
-      class UnaryFunction
-    , class Iterator
-    , class Reference = use_default
-    , class Value = use_default
-  >
-  class transform_iterator;
-
-  template <class Predicate, class Iterator>
-  class filter_iterator;
-
-  template <
-      class Incrementable
-    , class CategoryOrTraversal  = use_default
-    , class Difference = use_default
-  >
-  class counting_iterator;
-
-  template <class UnaryFunction>
-  class function_output_iterator;
-
-
-
-Iterator facade [lib.iterator.facade]
-=====================================
-
-.. include:: iterator_facade_abstract.rst
-
-Class template ``iterator_facade``
-----------------------------------
-
-.. include:: iterator_facade_ref.rst
-
-Iterator adaptor [lib.iterator.adaptor]
-=======================================
-
-.. include:: iterator_adaptor_abstract.rst
-
-Class template ``iterator_adaptor``
------------------------------------
-
-.. include:: iterator_adaptor_ref.rst
-
-
-Specialized adaptors [lib.iterator.special.adaptors]
-====================================================
-
-
-The ``enable_if_convertible<X,Y>::type`` expression used in
-this section is for exposition purposes. The converting constructors
-for specialized adaptors should be only be in an overload set provided
-that an object of type ``X`` is implicitly convertible to an object of
-type ``Y``.  
-The signatures involving ``enable_if_convertible`` should behave
-*as-if* ``enable_if_convertible`` were defined to be::
-
-  template <bool> enable_if_convertible_impl
-  {};
-
-  template <> enable_if_convertible_impl<true>
-  { struct type; };
-
-  template<typename From, typename To>
-  struct enable_if_convertible
-    : enable_if_convertible_impl<is_convertible<From,To>::value>
-  {};
-
-If an expression other than the default argument is used to supply
-the value of a function parameter whose type is written in terms
-of ``enable_if_convertible``, the program is ill-formed, no
-diagnostic required.
-
-[*Note:* The ``enable_if_convertible`` approach uses SFINAE to
-take the constructor out of the overload set when the types are not
-implicitly convertible.  
-]
-
-
-Indirect iterator
------------------
-
-.. include:: indirect_iterator_abstract.rst
-
-Class template ``pointee``
-....................................
-
-.. include:: pointee_ref.rst
-
-Class template ``indirect_reference``
-.....................................
-
-.. include:: indirect_reference_ref.rst
-
-Class template ``indirect_iterator``
-....................................
-
-.. include:: indirect_iterator_ref.rst
-
-Reverse iterator
-----------------
-
-.. include:: reverse_iterator_abstract.rst
-
-Class template ``reverse_iterator``
-...................................
-
-.. include:: reverse_iterator_ref.rst
-
-
-Transform iterator
-------------------
-
-.. include:: transform_iterator_abstract.rst
-
-Class template ``transform_iterator``
-.....................................
-
-.. include:: transform_iterator_ref.rst
-
-
-Filter iterator
----------------
-
-.. include:: filter_iterator_abstract.rst
-
-
-Class template ``filter_iterator``
-..................................
-
-.. include:: filter_iterator_ref.rst
-
-
-Counting iterator
------------------
-
-.. include:: counting_iterator_abstract.rst
-
-Class template ``counting_iterator``
-....................................
-
-.. include:: counting_iterator_ref.rst
-
-
-Function output iterator
-------------------------
-
-.. include:: function_output_iterator_abstract.rst
-
-Class template ``function_output_iterator``
-...........................................
-
-.. include:: function_output_iterator_ref.rst
-
-
-
-
-.. LocalWords:  Abrahams Siek Witt istream ostream iter MTL strided interoperate
-   LocalWords:  CRTP metafunctions inlining lvalue JGS incrementable BGL LEDA cv
-   LocalWords:  GraphBase struct ptrdiff UnaryFunction const int typename bool pp
-   LocalWords:  lhs rhs SFINAE markup iff tmp OtherDerived OtherIterator DWA foo
-   LocalWords:  dereferenceable subobject AdaptableUnaryFunction impl pre ifdef'd
-   LocalWords:  OtherIncrementable Coplien

doc/facade_iterator_category.rst

@@ -1,53 +0,0 @@
-.. |iterator-category| replace:: *iterator-category*
-.. _iterator-category:
-
-.. parsed-literal::
-  
-  *iterator-category*\ (C,R,V) :=
-     if (C is convertible to std::input_iterator_tag
-         || C is convertible to std::output_iterator_tag
-     )
-         return C
-
-     else if (C is not convertible to incrementable_traversal_tag)
-         *the program is ill-formed*
-
-     else return a type X satisfying the following two constraints:
-
-        1. X is convertible to X1, and not to any more-derived
-           type, where X1 is defined by:
-
-             if (R is a reference type
-                 && C is convertible to forward_traversal_tag)
-             {
-                 if (C is convertible to random_access_traversal_tag)
-                     X1 = random_access_iterator_tag
-                 else if (C is convertible to bidirectional_traversal_tag)
-                     X1 = bidirectional_iterator_tag
-                 else
-                     X1 = forward_iterator_tag
-             }
-             else
-             {
-                 if (C is convertible to single_pass_traversal_tag
-                     && R is convertible to V)
-                     X1 = input_iterator_tag
-                 else
-                     X1 = C
-             }
-
-        2. |category-to-traversal|_\ (X) is convertible to the most
-           derived traversal tag type to which X is also
-           convertible, and not to any more-derived traversal tag
-           type.
-
-.. |category-to-traversal| replace:: *category-to-traversal*
-.. _`category-to-traversal`: new-iter-concepts.html#category-to-traversal
-
-[Note: the intention is to allow ``iterator_category`` to be one of
-the five original category tags when convertibility to one of the
-traversal tags would add no information]
-
-.. 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)

doc/filter_iterator.html

@@ -1,390 +0,0 @@
-<?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.1: 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" />
-<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" />
-<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;ive.uni-hannover.de">witt&#64;ive.uni-hannover.de</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>, 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>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
-</tbody>
-</table>
-<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">abstract:</th><td class="field-body">The filter iterator adaptor creates a view of an iterator range in
-which some elements of the range are skipped. A predicate function
-object controls which elements are skipped. When the predicate is
-applied to an element, if it returns <tt class="literal"><span class="pre">true</span></tt> then the element is
-retained and if it returns <tt class="literal"><span class="pre">false</span></tt> then the element is skipped
-over. When skipping over elements, it is necessary for the filter
-adaptor to know when to stop so as to avoid going past the end of the
-underlying range. A filter iterator is therefore constructed with pair
-of iterators indicating the range of elements in the unfiltered
-sequence to be traversed.</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>
-<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>
-</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>
-<!-- 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 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>
-<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 class="toc-backref" href="#id4" 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">
-<colgroup>
-<col width="33%" />
-<col width="67%" />
-</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>
-</tbody>
-</table>
-<table border 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 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>
-</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>
-<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>
-<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>
-<div class="section" id="example">
-<h1><a class="toc-backref" href="#id6" 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
-the integers greater than <tt class="literal"><span class="pre">-2</span></tt>.</p>
-<pre class="literal-block">
-struct is_positive_number {
-  bool operator()(int x) { return 0 &lt; x; }
-};
-
-int main()
-{
-  int numbers_[] = { 0, -1, 4, -3, 5, 8, -2 };
-  const int N = sizeof(numbers_)/sizeof(int);
-
-  typedef int* base_iterator;
-  base_iterator numbers(numbers_);
-
-  // Example using filter_iterator
-  typedef boost::filter_iterator&lt;is_positive_number, base_iterator&gt;
-    FilterIter;
-
-  is_positive_number predicate;
-  FilterIter filter_iter_first(predicate, numbers, numbers + N);
-  FilterIter filter_iter_last(predicate, numbers + N, numbers + N);
-
-  std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
-  std::cout &lt;&lt; std::endl;
-
-  // Example using make_filter_iterator()
-  std::copy(boost::make_filter_iterator&lt;is_positive_number&gt;(numbers, numbers + N),
-            boost::make_filter_iterator&lt;is_positive_number&gt;(numbers + N, numbers + N),
-            std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
-  std::cout &lt;&lt; std::endl;
-
-  // Another example using make_filter_iterator()
-  std::copy(
-      boost::make_filter_iterator(
-          std::bind2nd(std::greater&lt;int&gt;(), -2)
-        , numbers, numbers + N)
-
-    , boost::make_filter_iterator(
-          std::bind2nd(std::greater&lt;int&gt;(), -2)
-        , numbers + N, numbers + N)
-
-    , std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;)
-  );
-
-  std::cout &lt;&lt; std::endl;
-
-  return boost::exit_success;
-}
-</pre>
-<p>The output is:</p>
-<pre class="literal-block">
-4 5 8 
-4 5 8 
-0 -1 4 5 8 
-</pre>
-<p>The source code for this example can be found <a class="reference" href="../example/filter_iterator_example.cpp">here</a>.</p>
-</div>
-</div>
-<hr class="footer" />
-<div class="footer">
-<a class="reference" href="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/filter_iterator.rst

@@ -1,29 +0,0 @@
-+++++++++++++++++
- Filter Iterator
-+++++++++++++++++
-
-:Author: David Abrahams, Jeremy Siek, Thomas Witt
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@ive.uni-hannover.de
-:organization: `Boost Consulting`_, Indiana University `Open Systems
-               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
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-.. _`Open Systems Lab`: http://www.osl.iu.edu
-.. _`Institute for Transport Railway Operation and Construction`: http://www.ive.uni-hannover.de
-
-:abstract:
-
-  .. include:: filter_iterator_abstract.rst
-
-.. contents:: Table of Contents
-
-``filter_iterator`` synopsis
-............................
-
-.. include:: filter_iterator_ref.rst
-.. include:: make_filter_iterator.rst
-
-.. include:: filter_iterator_eg.rst

doc/filter_iterator_abstract.rst

@@ -1,11 +0,0 @@
-The filter iterator adaptor creates a view of an iterator range in
-which some elements of the range are skipped. A predicate function
-object controls which elements are skipped. When the predicate is
-applied to an element, if it returns ``true`` then the element is
-retained and if it returns ``false`` then the element is skipped
-over. When skipping over elements, it is necessary for the filter
-adaptor to know when to stop so as to avoid going past the end of the
-underlying range. A filter iterator is therefore constructed with pair
-of iterators indicating the range of elements in the unfiltered
-sequence to be traversed.
-

doc/filter_iterator_eg.rst

@@ -1,69 +0,0 @@
-
-Example
-.......
-
-This example uses ``filter_iterator`` and then
-``make_filter_iterator`` to output only the positive integers from an
-array of integers. Then ``make_filter_iterator`` is is used to output
-the integers greater than ``-2``.
-
-::
-
-    struct is_positive_number {
-      bool operator()(int x) { return 0 < x; }
-    };
-
-    int main()
-    {
-      int numbers_[] = { 0, -1, 4, -3, 5, 8, -2 };
-      const int N = sizeof(numbers_)/sizeof(int);
-
-      typedef int* base_iterator;
-      base_iterator numbers(numbers_);
-
-      // Example using filter_iterator
-      typedef boost::filter_iterator<is_positive_number, base_iterator>
-	FilterIter;
-
-      is_positive_number predicate;
-      FilterIter filter_iter_first(predicate, numbers, numbers + N);
-      FilterIter filter_iter_last(predicate, numbers + N, numbers + N);
-
-      std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator<int>(std::cout, " "));
-      std::cout << std::endl;
-
-      // Example using make_filter_iterator()
-      std::copy(boost::make_filter_iterator<is_positive_number>(numbers, numbers + N),
-		boost::make_filter_iterator<is_positive_number>(numbers + N, numbers + N),
-		std::ostream_iterator<int>(std::cout, " "));
-      std::cout << std::endl;
-
-      // Another example using make_filter_iterator()
-      std::copy(
-	  boost::make_filter_iterator(
-	      std::bind2nd(std::greater<int>(), -2)
-	    , numbers, numbers + N)
-
-	, boost::make_filter_iterator(
-	      std::bind2nd(std::greater<int>(), -2)
-	    , numbers + N, numbers + N)
-
-	, std::ostream_iterator<int>(std::cout, " ")
-      );
-
-      std::cout << std::endl;
-
-      return boost::exit_success;
-    }
-
-
-The output is::
-
-    4 5 8 
-    4 5 8 
-    0 -1 4 5 8 
-
-
-The source code for this example can be found `here`__.
-
-__ ../example/filter_iterator_example.cpp

doc/filter_iterator_ref.html

@@ -1,241 +0,0 @@
-<?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.2.8: http://docutils.sourceforge.net/" />
-<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;
-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 base() const;
-    reference operator*() const;
-    filter_iterator&amp; operator++();
-private:
-    Predicate m_pred; // exposition
-    Iterator m_iter;  // exposition
-    Iterator m_end;   // exposition
-};
-</pre>
-<p>The <tt class="literal"><span class="pre">iterator_category</span></tt> member is a type convertible to the tags
-corresponding to each standard concept modeled by <tt class="literal"><span class="pre">filter_iterator</span></tt>,
-as described in the models section.</p>
-<div class="section" id="filter-iterator-requirements">
-<h1><a name="filter-iterator-requirements"><tt class="literal"><span class="pre">filter_iterator</span></tt> requirements</a></h1>
-<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>
-<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>
-</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 class="table" frame="border" rules="all">
-<colgroup>
-<col width="33%" />
-<col width="67%" />
-</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>
-</tbody>
-</table>
-<table class="table" frame="border" rules="all">
-<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 class="table" frame="border" rules="all">
-<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>
-</tbody>
-</table>
-</div>
-<div class="section" id="filter-iterator-operations">
-<h1><a name="filter-iterator-operations"><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">Returns:</th><td class="field-body">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">Returns:</th><td class="field-body">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.</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">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">Returns:</th><td class="field-body">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">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 on: 2004-01-13 02:57 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>
-</html>

doc/filter_iterator_ref.rst

@@ -1,169 +0,0 @@
-.. 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) 
-
-::
-
-  template <class Predicate, class Iterator>
-  class filter_iterator
-  {
-   public:
-      typedef iterator_traits<Iterator>::value_type value_type;
-      typedef iterator_traits<Iterator>::reference reference;
-      typedef iterator_traits<Iterator>::pointer pointer;
-      typedef iterator_traits<Iterator>::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<class OtherIterator>
-      filter_iterator(
-          filter_iterator<Predicate, OtherIterator> const& t
-          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
-          );
-      Predicate predicate() const;
-      Iterator end() const;
-      Iterator const& base() const;
-      reference operator*() const;
-      filter_iterator& operator++();
-  private:
-      Predicate m_pred; // exposition only
-      Iterator m_iter;  // exposition only
-      Iterator m_end;   // exposition only
-  };
-
-
-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``.
-
-
-``filter_iterator`` requirements
-................................
-
-The ``Iterator`` argument shall meet the requirements of Readable
-Iterator and Single Pass Iterator or it shall meet the requirements of
-Input Iterator.
-
-The ``Predicate`` argument must be Assignable, Copy Constructible, and
-the expression ``p(x)`` must be valid where ``p`` is an object of type
-``Predicate``, ``x`` is an object of type
-``iterator_traits<Iterator>::value_type``, and where the type of
-``p(x)`` must be convertible to ``bool``.
-
-
-``filter_iterator`` models
-..........................
-
-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              |
-+================================+==============================================+
-| Readable Iterator              | Readable Iterator                            |
-+--------------------------------+----------------------------------------------+
-| Writable Iterator              | Writable Iterator                            |
-+--------------------------------+----------------------------------------------+
-| Lvalue Iterator                | Lvalue Iterator                              |
-+--------------------------------+----------------------------------------------+
-
-+-------------------------------------------------------+---------------------------------+
-| If ``Iterator`` models                                | then ``filter_iterator`` models |
-+=======================================================+=================================+
-| Readable Iterator, Single Pass Iterator               | Input Iterator                  |
-+-------------------------------------------------------+---------------------------------+
-| Readable Lvalue Iterator, Forward Traversal Iterator  | Forward Iterator                |
-+-------------------------------------------------------+---------------------------------+
-| Writable Lvalue Iterator, Forward Traversal Iterator  | Mutable Forward Iterator        |
-+-------------------------------------------------------+---------------------------------+
-
-
-``filter_iterator<P1, X>`` is interoperable with ``filter_iterator<P2, Y>`` 
-if and only if ``X`` is interoperable with ``Y``.
-
-
-``filter_iterator`` operations
-..............................
-
-In addition to those operations required by the concepts that
-``filter_iterator`` models, ``filter_iterator`` provides the following
-operations.
-
-
-``filter_iterator();``
-
-:Requires: ``Predicate`` and ``Iterator`` must be Default Constructible.
-:Effects: Constructs a ``filter_iterator`` whose``m_pred``,  ``m_iter``, and ``m_end`` 
-  members are a default constructed.
-
-
-``filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());``
-
-:Effects: Constructs a ``filter_iterator`` where ``m_iter`` is either
-    the first position in the range ``[x,end)`` such that ``f(*m_iter) == true`` 
-    or else``m_iter == end``. The member ``m_pred`` is constructed from
-    ``f`` and ``m_end`` from ``end``.
-
-
-
-``filter_iterator(Iterator x, Iterator end = Iterator());``
-
-:Requires: ``Predicate`` must be Default Constructible and
-  ``Predicate`` is a class type (not a function pointer).
-:Effects: Constructs a ``filter_iterator`` where ``m_iter`` is either
-    the first position in the range ``[x,end)`` such that ``m_pred(*m_iter) == true`` 
-    or else``m_iter == end``. The member ``m_pred`` is default constructed.
-
-
-::
-
-    template <class OtherIterator>
-    filter_iterator(
-        filter_iterator<Predicate, OtherIterator> const& t
-        , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
-        );``
-
-:Requires: ``OtherIterator`` is implicitly convertible to ``Iterator``.
-:Effects: Constructs a filter iterator whose members are copied from ``t``.
-
-
-``Predicate predicate() const;``
-
-:Returns: ``m_pred``
-
-
-``Iterator end() const;``
-
-:Returns: ``m_end``
-
-
-``Iterator const& base() const;``
-
-:Returns: ``m_iterator``
-
-
-
-``reference operator*() const;``
-
-:Returns: ``*m_iter``
-
-
-``filter_iterator& operator++();``
-
-:Effects: Increments ``m_iter`` and then continues to
-  increment ``m_iter`` until either ``m_iter == m_end``
-  or ``m_pred(*m_iter) == true``.
-:Returns: ``*this``  

doc/function_output_iterator.html

@@ -1,171 +0,0 @@
-<?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.1: 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" />
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="function-output-iterator">
-<h1 class="title">Function Output Iterator</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;ive.uni-hannover.de">witt&#64;ive.uni-hannover.de</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>, 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>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
-</tbody>
-</table>
-<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">abstract:</th><td class="field-body">The function output iterator adaptor makes it easier to create custom
-output iterators. The adaptor takes a unary function and creates a
-model of Output Iterator. Each item assigned to the output iterator is
-passed as an argument to the unary function.  The motivation for this
-iterator is that creating a conforming output iterator is non-trivial,
-particularly because the proper implementation usually requires a
-proxy object.</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>
-<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="#example" id="id4" name="id4">Example</a></li>
-</ul>
-</div>
-<pre class="literal-block">
-template &lt;class UnaryFunction&gt;
-class function_output_iterator {
-public:
-  typedef std::output_iterator_tag iterator_category;
-  typedef void                     value_type;
-  typedef void                     difference_type;
-  typedef void                     pointer;
-  typedef void                     reference;
-
-  explicit function_output_iterator();
-
-  explicit function_output_iterator(const UnaryFunction&amp; f);
-
-  /* see below */ operator*();
-  function_output_iterator&amp; operator++();
-  function_output_iterator&amp; operator++(int);
-private:
-  UnaryFunction m_f;     // exposition only
-};
-</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>
-</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
-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">
-<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>
-</tbody>
-</table>
-<p><tt class="literal"><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">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>
-</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">
-<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>
-</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">
-<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>
-</tbody>
-</table>
-</div>
-<div class="section" id="example">
-<h1><a class="toc-backref" href="#id4" name="example">Example</a></h1>
-<pre class="literal-block">
-struct string_appender
-{
-    string_appender(std::string&amp; s)
-        : m_str(&amp;s)
-    {}
-
-    void operator()(const std::string&amp; x) const
-    {
-        *m_str += x;
-    }
-
-    std::string* m_str;
-};
-
-int main(int, char*[])
-{
-  std::vector&lt;std::string&gt; x;
-  x.push_back(&quot;hello&quot;);
-  x.push_back(&quot; &quot;);
-  x.push_back(&quot;world&quot;);
-  x.push_back(&quot;!&quot;);
-
-  std::string s = &quot;&quot;;
-  std::copy(x.begin(), x.end(), 
-            boost::make_function_output_iterator(string_appender(s)));
-
-  std::cout &lt;&lt; s &lt;&lt; std::endl;
-
-  return 0;
-}
-</pre>
-</div>
-</div>
-<hr class="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

@@ -1,24 +0,0 @@
-++++++++++++++++++++++++++
- Function Output Iterator
-++++++++++++++++++++++++++
-
-:Author: David Abrahams, Jeremy Siek, Thomas Witt
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@ive.uni-hannover.de
-:organization: `Boost Consulting`_, Indiana University `Open Systems
-               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
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-.. _`Open Systems Lab`: http://www.osl.iu.edu
-.. _`Institute for Transport Railway Operation and Construction`: http://www.ive.uni-hannover.de
-
-:abstract:
-
-  .. include:: function_output_iterator_abstract.rst
-
-.. contents:: Table of Contents
-
-.. include:: function_output_iterator_ref.rst
-.. include:: function_output_iterator_eg.rst

doc/function_output_iterator_abstract.rst

@@ -1,8 +0,0 @@
-The function output iterator adaptor makes it easier to create custom
-output iterators. The adaptor takes a unary function and creates a
-model of Output Iterator. Each item assigned to the output iterator is
-passed as an argument to the unary function.  The motivation for this
-iterator is that creating a conforming output iterator is non-trivial,
-particularly because the proper implementation usually requires a
-proxy object.
-

doc/function_output_iterator_eg.rst

@@ -1,35 +0,0 @@
-Example
-.......
-
-::
-
-    struct string_appender
-    {
-	string_appender(std::string& s)
-	    : m_str(&s)
-	{}
-
-	void operator()(const std::string& x) const
-	{
-	    *m_str += x;
-	}
-
-	std::string* m_str;
-    };
-
-    int main(int, char*[])
-    {
-      std::vector<std::string> x;
-      x.push_back("hello");
-      x.push_back(" ");
-      x.push_back("world");
-      x.push_back("!");
-
-      std::string s = "";
-      std::copy(x.begin(), x.end(), 
-		boost::make_function_output_iterator(string_appender(s)));
-
-      std::cout << s << std::endl;
-
-      return 0;
-    }

doc/function_output_iterator_ref.rst

@@ -1,62 +0,0 @@
-::
-
-  template <class UnaryFunction>
-  class function_output_iterator {
-  public:
-    typedef std::output_iterator_tag iterator_category;
-    typedef void                     value_type;
-    typedef void                     difference_type;
-    typedef void                     pointer;
-    typedef void                     reference;
-
-    explicit function_output_iterator();
-
-    explicit function_output_iterator(const UnaryFunction& f);
-
-    /* see below */ operator*();
-    function_output_iterator& operator++();
-    function_output_iterator& operator++(int);
-  private:
-    UnaryFunction m_f;     // exposition only
-  };
-
-
-
-``function_output_iterator`` requirements
-.........................................
-
-``UnaryFunction`` must be Assignable and Copy Constructible.  
-
-
-
-``function_output_iterator`` models
-...................................
-
-``function_output_iterator`` is a model of the Writable and
-Incrementable Iterator concepts.
-
-
-
-``function_output_iterator`` operations
-.......................................
-
-``explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());``
-
-:Effects: Constructs an instance of ``function_output_iterator`` 
-  with ``m_f`` constructed from ``f``.
-
-
-``operator*();``
-
-:Returns: An object ``r`` of unspecified type such that ``r = t``
-  is equivalent to ``m_f(t)`` for all ``t``.
-  
-
-``function_output_iterator& operator++();``
-
-:Returns: ``*this``
-
-
-``function_output_iterator& operator++(int);``
-
-:Returns: ``*this``

doc/generate.py

@@ -1,32 +0,0 @@
-#!/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
-#
-import os
-import sys
-
-from syscmd import syscmd
-from sources import sources
-
-if 0:
-    for s in sources:
-        syscmd('boosthtml %s' % s)
-else:        
-    extensions = ('html', 'pdf')
-
-    if len(sys.argv) > 1:
-        extensions = sys.argv[1:]
-
-    all = [ '%s.%s' % (os.path.splitext(s)[0],ext)
-          for ext in extensions
-          for s in sources 
-        ]
-
-    print 'make %s' % ' '.join(all)
-    syscmd('make %s' % ' '.join(all))
-
-

doc/index.html

@@ -1,241 +0,0 @@
-<?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.4: http://docutils.sourceforge.net/" />
-<title>The Boost.Iterator Library Boost</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<h1 class="title">The Boost.Iterator Library <a class="reference" href="../../../index.htm"><img alt="Boost" src="../../../c++boost.gif" /></a></h1>
-<div class="document" id="the-boost-iterator-library-logo">
-<hr />
-<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">Authors:</th><td class="field-body">David Abrahams, Jeremy Siek, Thomas Witt</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>, <a class="reference" href="mailto:witt&#64;styleadvisor.com">witt&#64;styleadvisor.com</a></td>
-</tr>
-<tr class="field"><th class="field-name">organizations:</th><td class="field-body"><a class="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="reference" href="http://www.styleadvisor.com">Zephyr Associates, Inc.</a></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, Thomas Witt 2003. All rights reserved</td>
-</tr>
-</tbody>
-</table>
-<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">Abstract:</th><td class="field-body">The Boost Iterator Library contains two parts. The first
-is a system of <a class="reference" href="../../../more/generic_programming.html#concept">concepts</a> which extend the C++ standard
-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 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
-take full advantage of the new-style iterator
-capabilities.  Several components of this library have
-been accepted into the C++ standard technical report.
-The components of the Boost Iterator Library replace the
-older Boost Iterator Adaptor Library.</td>
-</tr>
-</tbody>
-</table>
-<div class="contents topic" id="table-of-contents">
-<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="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="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 />
-<div class="section" id="new-style-iterators">
-<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
-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
-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> (<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="#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,
-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
-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> (<a class="reference" href="iterator_facade.pdf">PDF</a>)</li>
-<li><a class="reference" href="iterator_adaptor.html"><tt class="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
-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> (<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="#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> (<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> (<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="function_output_iterator.html"><tt class="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="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> (<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> (<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="../../utility/shared_container_iterator.html"><tt class="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="literal"><span class="pre">shared_ptr</span></tt></a> stored in the iterator.</li>
-<li><a class="reference" href="transform_iterator.html"><tt class="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> (<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="#id25" name="iterator-utilities">Iterator Utilities</a></h1>
-<div class="section" id="traits">
-<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> (<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> (<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>
-</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="#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> (<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="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="#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
-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
-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="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
-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>
-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>
-</div>
-<div class="section" id="history">
-<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
-generalize the idea and the Boost Iterator Adaptor library was born.
-Dave was inspired by some writings of Andrei Alexandrescu and chose a
-policy based design (though he probably didn't capture Andrei's idea
-very well - there was only one policy class for all the iterator's
-orthogonal properties).  Soon Jeremy Siek realized he would need the
-library and they worked together to produce a &quot;Boostified&quot; version,
-which was reviewed and accepted into the library.  They wrote a paper
-and made several important revisions of the code.</p>
-<p>Eventually, several shortcomings of the older library began to make
-the need for a rewrite apparent.  Dave and Jeremy started working
-at the Santa Cruz C++ committee meeting in 2002, and had quickly
-generated a working prototype.  At the urging of Mat Marcus, they
-decided to use the GenVoca/CRTP pattern approach, and moved the
-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
-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">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<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>
-<!-- LocalWords:  Abrahams Siek Witt const bool Sutter's WG int UL LI href Lvalue
-LocalWords:  ReadableIterator WritableIterator SwappableIterator cv pre iter
-LocalWords:  ConstantLvalueIterator MutableLvalueIterator CopyConstructible TR
-LocalWords:  ForwardTraversalIterator BidirectionalTraversalIterator lvalue
-LocalWords:  RandomAccessTraversalIterator dereferenceable Incrementable tmp
-LocalWords:  incrementable xxx min prev inplace png oldeqnew AccessTag struct
-LocalWords:  TraversalTag typename lvalues DWA Hmm JGS -->
-</div>
-</div>
-<hr class="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.
-</div>
-</body>
-</html>

doc/index.rst

@@ -1,319 +0,0 @@
-+++++++++++++++++++++++++++++++++++++++++++++++++
- The Boost.Iterator Library |(logo)|__
-+++++++++++++++++++++++++++++++++++++++++++++++++
-
-.. |(logo)| image:: ../../../c++boost.gif
-   :alt: Boost
-
-__ ../../../index.htm
-
-
--------------------------------------
-
-
-:Authors:       David Abrahams, Jeremy Siek, Thomas Witt
-:Contact:       dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
-:organizations: `Boost Consulting`_, Indiana University `Open Systems
-                Lab`_, `Zephyr Associates, Inc.`_
-:date:          $Date$
-
-:copyright:     Copyright David Abrahams, Jeremy Siek, Thomas Witt 2003. All rights reserved
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-.. _`Open Systems Lab`: http://www.osl.iu.edu
-.. _`Zephyr Associates, Inc.`: http://www.styleadvisor.com
-
-:Abstract: The Boost Iterator Library contains two parts. The first
-           is a system of concepts_ which extend the C++ standard
-           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 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
-           take full advantage of the new-style iterator
-           capabilities.  Several components of this library have
-           been accepted into the C++ standard technical report.
-           The components of the Boost Iterator Library replace the
-           older Boost Iterator Adaptor Library.
-
-.. _concepts: ../../../more/generic_programming.html#concept
-
-.. contents:: **Table of Contents**
-
-
--------------------------------------
-
-
-=====================
- New-Style Iterators
-=====================
-
-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
-``vector<bool>::iterator`` using the C++98 categories.  This is the
-infamous "``vector<bool>`` is not a container, and its iterators
-aren't random access iterators", debacle about which Herb Sutter
-wrote two papers for the standards comittee (n1185_ and n1211_),
-and a `Guru of the Week`__.  New-style iterators go well beyond
-patching up ``vector<bool>``, 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
-
-.. _n1185: http://www.gotw.ca/publications/N1185.pdf
-.. _n1211: http://www.gotw.ca/publications/N1211.pdf
-__ http://www.gotw.ca/gotw/050.htm
-
-
-   `Standard Proposal For New-Style Iterators`__ (PDF__)
-
-__ new-iter-concepts.html
-__ new-iter-concepts.pdf
-
-=============================
- Iterator Facade and Adaptor
-=============================
-
-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 |facade| class template,
-which implements many useful defaults and compile-time checks
-designed to help the iterator author ensure that his iterator is
-correct.  
-
-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 |adaptor| class template, which is specially
-designed to take advantage of as much of the underlying type's
-behavior as possible.
-
-The documentation for these two classes can be found at the following
-web pages:
-
-* |facade|_ (PDF__)
-
-* |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`__ (PDF__)
-
-for more details.
-
-__ facade-and-adaptor.html
-__ facade-and-adaptor.pdf
-
-======================
- Specialized Adaptors
-======================
-
-The iterator library supplies a useful suite of standard-conforming
-iterator templates based on the Boost `iterator facade and adaptor`_.
-
-* |counting|_ (PDF__): an iterator over a sequence of consecutive values.
-  Implements a "lazy sequence"
-
-* |filter|_ (PDF__): an iterator over the subset of elements of some
-  sequence which satisfy a given predicate
-
-* |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|_ (PDF__): an iterator over the elements of some random-access
-  sequence, rearranged according to some sequence of integer indices.
-
-* |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``.
-
-* |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|_ (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
-====================
-
-Traits
-------
-
-* |pointee|_ (PDF__): Provides the capability to deduce the referent types
-  of pointers, smart pointers and iterators in generic code.  Used
-  in |indirect|.
-
-* |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|_ (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|_ (PDF__): Concept checking classes for the new iterator 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
-=======================================================
-
-.. _Upgrading:
-
-If you have been using the old Boost Iterator Adaptor library to
-implement iterators, you probably wrote a ``Policies`` 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 `type generator`_ to build the
-``iterator_adaptor`` 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) [Cop95]_,
-you can now define the iterator class yourself and acquire
-functionality through inheritance from ``iterator_facade`` or
-``iterator_adaptor``.  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.
-
-.. _`type generator`: ../../../more/generic_programming.html#type_generator
-
-If you're looking for the old ``projection_iterator`` component,
-its functionality has been merged into ``transform_iterator``: as
-long as the function object's ``result_type`` (or the ``Reference``
-template argument, if explicitly specified) is a true reference
-type, ``transform_iterator`` will behave like
-``projection_iterator`` used to.
-
-=========
- History
-=========
-
-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
-generalize the idea and the Boost Iterator Adaptor library was born.
-Dave was inspired by some writings of Andrei Alexandrescu and chose a
-policy based design (though he probably didn't capture Andrei's idea
-very well - there was only one policy class for all the iterator's
-orthogonal properties).  Soon Jeremy Siek realized he would need the
-library and they worked together to produce a "Boostified" version,
-which was reviewed and accepted into the library.  They wrote a paper
-and made several important revisions of the code.
-
-Eventually, several shortcomings of the older library began to make
-the need for a rewrite apparent.  Dave and Jeremy started working
-at the Santa Cruz C++ committee meeting in 2002, and had quickly
-generated a working prototype.  At the urging of Mat Marcus, they
-decided to use the GenVoca/CRTP pattern approach, and moved the
-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 ``iterator_facade``, and
-factored it out of ``iterator_adaptor``.  Finally, after a
-near-complete rewrite of the prototype, they came up with the
-library you see today.
-
-.. [Cop95] [Coplien, 1995] Coplien, J., Curiously Recurring Template
-   Patterns, C++ Report, February 1995, pp. 24-27.
-
-..
- LocalWords:  Abrahams Siek Witt const bool Sutter's WG int UL LI href Lvalue
- LocalWords:  ReadableIterator WritableIterator SwappableIterator cv pre iter
- LocalWords:  ConstantLvalueIterator MutableLvalueIterator CopyConstructible TR
- LocalWords:  ForwardTraversalIterator BidirectionalTraversalIterator lvalue
- LocalWords:  RandomAccessTraversalIterator dereferenceable Incrementable tmp
- LocalWords:  incrementable xxx min prev inplace png oldeqnew AccessTag struct
- LocalWords:  TraversalTag typename lvalues DWA Hmm JGS

doc/indirect_iterator.html

@@ -1,332 +0,0 @@
-<?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.1: 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" />
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="indirect-iterator">
-<h1 class="title">Indirect Iterator</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;ive.uni-hannover.de">witt&#64;ive.uni-hannover.de</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>, 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>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
-</tbody>
-</table>
-<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">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
-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
-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>
-<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="#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>
-<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>
-<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>
-<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 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>
-<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 class="toc-backref" href="#id5" 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 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
-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>
-<pre class="literal-block">
-char characters[] = &quot;abcdefg&quot;;
-const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
-char* pointers_to_chars[N];                        // at the end.
-for (int i = 0; i &lt; N; ++i)
-  pointers_to_chars[i] = &amp;characters[i];
-
-// Example of using indirect_iterator
-
-boost::indirect_iterator&lt;char**, char&gt;
-  indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
-
-std::copy(indirect_first, indirect_last, std::ostream_iterator&lt;char&gt;(std::cout, &quot;,&quot;));
-std::cout &lt;&lt; std::endl;
-
-
-// Example of making mutable and constant indirect iterators
-
-char mutable_characters[N];
-char* pointers_to_mutable_chars[N];
-for (int j = 0; j &lt; N; ++j)
-  pointers_to_mutable_chars[j] = &amp;mutable_characters[j];
-
-boost::indirect_iterator&lt;char* const*&gt; mutable_indirect_first(pointers_to_mutable_chars),
-  mutable_indirect_last(pointers_to_mutable_chars + N);
-boost::indirect_iterator&lt;char* const*, char const&gt; const_indirect_first(pointers_to_chars),
-  const_indirect_last(pointers_to_chars + N);
-
-std::transform(const_indirect_first, const_indirect_last,
-               mutable_indirect_first, std::bind1st(std::plus&lt;char&gt;(), 1));
-
-std::copy(mutable_indirect_first, mutable_indirect_last,
-          std::ostream_iterator&lt;char&gt;(std::cout, &quot;,&quot;));
-std::cout &lt;&lt; std::endl;
-
-
-// Example of using make_indirect_iterator()
-
-std::copy(boost::make_indirect_iterator(pointers_to_chars), 
-          boost::make_indirect_iterator(pointers_to_chars + N),
-          std::ostream_iterator&lt;char&gt;(std::cout, &quot;,&quot;));
-std::cout &lt;&lt; std::endl;
-</pre>
-<p>The output is:</p>
-<pre class="literal-block">
-a,b,c,d,e,f,g,
-b,c,d,e,f,g,h,
-a,b,c,d,e,f,g,
-</pre>
-<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" />
-<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.
-</div>
-</body>
-</html>

doc/indirect_iterator.rst

@@ -1,30 +0,0 @@
-+++++++++++++++++++
- Indirect Iterator
-+++++++++++++++++++
-
-:Author: David Abrahams, Jeremy Siek, Thomas Witt
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@ive.uni-hannover.de
-:organization: `Boost Consulting`_, Indiana University `Open Systems
-               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
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-.. _`Open Systems Lab`: http://www.osl.iu.edu
-.. _`Institute for Transport Railway Operation and Construction`: http://www.ive.uni-hannover.de
-
-:abstract:
-
-  .. include:: indirect_iterator_abstract.rst
-
-.. contents:: Table of Contents
-
-``indirect_iterator`` synopsis
-..............................
-
-.. include:: indirect_iterator_ref.rst
-.. include:: indirect_iterator_eg.rst
-
-.. _iterator-category: iterator_facade.html#iterator-category
-.. |iterator-category| replace:: *iterator-category*

doc/indirect_iterator_abstract.rst

@@ -1,11 +0,0 @@
-``indirect_iterator`` adapts an iterator by applying an
-*extra* dereference inside of ``operator*()``. For example, this
-iterator adaptor makes it possible to view a container of pointers
-(e.g. ``list<foo*>``) as if it were a container of the pointed-to type
-(e.g. ``list<foo>``).  ``indirect_iterator`` depends on two
-auxiliary traits, ``pointee`` and ``indirect_reference``, to
-provide support for underlying iterators whose ``value_type`` is
-not an iterator.
-
-
-

doc/indirect_iterator_eg.rst

@@ -1,69 +0,0 @@
-Example
-.......
-
-This example prints an array of characters, using
-``indirect_iterator`` to access the array of characters through an
-array of pointers. Next ``indirect_iterator`` is used with the
-``transform`` 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 ``make_indirect_iterator`` helper function.
-
-
-::
-
-    char characters[] = "abcdefg";
-    const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
-    char* pointers_to_chars[N];                        // at the end.
-    for (int i = 0; i < N; ++i)
-      pointers_to_chars[i] = &characters[i];
-
-    // Example of using indirect_iterator
-
-    boost::indirect_iterator<char**, char>
-      indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);
-
-    std::copy(indirect_first, indirect_last, std::ostream_iterator<char>(std::cout, ","));
-    std::cout << std::endl;
-
-
-    // Example of making mutable and constant indirect iterators
-
-    char mutable_characters[N];
-    char* pointers_to_mutable_chars[N];
-    for (int j = 0; j < N; ++j)
-      pointers_to_mutable_chars[j] = &mutable_characters[j];
-
-    boost::indirect_iterator<char* const*> mutable_indirect_first(pointers_to_mutable_chars),
-      mutable_indirect_last(pointers_to_mutable_chars + N);
-    boost::indirect_iterator<char* const*, char const> const_indirect_first(pointers_to_chars),
-      const_indirect_last(pointers_to_chars + N);
-
-    std::transform(const_indirect_first, const_indirect_last,
-		   mutable_indirect_first, std::bind1st(std::plus<char>(), 1));
-
-    std::copy(mutable_indirect_first, mutable_indirect_last,
-	      std::ostream_iterator<char>(std::cout, ","));
-    std::cout << std::endl;
-
-
-    // Example of using make_indirect_iterator()
-
-    std::copy(boost::make_indirect_iterator(pointers_to_chars), 
-	      boost::make_indirect_iterator(pointers_to_chars + N),
-	      std::ostream_iterator<char>(std::cout, ","));
-    std::cout << std::endl;
-
-
-The output is::
-
-    a,b,c,d,e,f,g,
-    b,c,d,e,f,g,h,
-    a,b,c,d,e,f,g,
-
-
-The source code for this example can be found `here`__.
-
-__ ../example/indirect_iterator_example.cpp
-

doc/indirect_iterator_ref.diff

@@ -1,245 +0,0 @@
-Index: indirect_iterator_ref.rst
-===================================================================
-RCS file: /cvsroot/boost/boost/libs/iterator/doc/indirect_iterator_ref.rst,v
-retrieving revision 1.2
-retrieving revision 1.21
-diff -w -d -u -b -r1.2 -r1.21
---- indirect_iterator_ref.rst	22 Sep 2003 19:55:00 -0000	1.2
-+++ indirect_iterator_ref.rst	15 Jan 2004 00:01:33 -0000	1.21
-
-
-
-@@ -3,82 +3,139 @@
-   template <
-       class Iterator
-     , class Value = use_default
-
-Issue 9.15
-
--    , unsigned Access  = use_default_access
--    , class Traversal  = use_default
-+    , class CategoryOrTraversal = use_default
-     , class Reference = use_default
-     , class Difference = use_default
-   >
-   class indirect_iterator
-
-Issue 9.37x
-
--    : public iterator_adaptor</* see discussion */>
-   {
--      friend class iterator_core_access;
-    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);
-+
-
-Issue 9.15
-
-       template <
--          class Iterator2, class Value2, unsigned Access2, class Traversal2
-+          class Iterator2, class Value2, class Category2
-         , class Reference2, class Difference2
-       >
-       indirect_iterator(
-           indirect_iterator<
--               Iterator2, Value2, Access2, Traversal2, Reference2, Difference2
-+               Iterator2, Value2, Category2, Reference2, Difference2
-           > const& y
-         , typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
-       );
-
-Issue 9.37x
-
--  private: // as-if specification
--      typename indirect_iterator::reference dereference() const
--      {
--          return **this->base();
--      }
-+
-+      Iterator const& base() const;
-+      reference operator*() const;
-+      indirect_iterator& operator++();
-+      indirect_iterator& operator--();
-+  private:
-+     Iterator m_iterator; // exposition
-   };
- 
-+
-+The member types of ``indirect_iterator`` are defined according to
-+the following pseudo-code, where ``V`` is
-+``iterator_traits<Iterator>::value_type``
-+
-+.. parsed-literal::
-+
-+  if (Value is use_default) then
-+      typedef remove_const<pointee<V>::type>::type value_type;
-+  else
-+      typedef remove_const<Value>::type value_type;
-+
-+  if (Reference is use_default) then
-+      if (Value is use_default) then
-+          typedef indirect_reference<V>::type reference;
-+      else
-+          typedef Value& reference;
-+  else
-+      typedef Reference reference;
-+
-+  if (Value is use_default) then 
-+      typedef pointee<V>::type\* pointer;
-+  else 
-+      typedef Value\* pointer;
-+
-+  if (Difference is use_default)
-+      typedef iterator_traits<Iterator>::difference_type difference_type;
-+  else
-+      typedef Difference difference_type;
-+
-+  if (CategoryOrTraversal is use_default)
-+      typedef |iterator-category|_\ (
-+          iterator_traversal<Iterator>::type,``reference``,``value_type``
-+      ) iterator_category;
-+  else
-+      typedef |iterator-category|_\ (
-+          CategoryOrTraversal,``reference``,``value_type``
-+      ) iterator_category;
-+
-+
-
- ``indirect_iterator`` requirements
- ..................................
-
-Issue 9.40x
- 
--The ``value_type`` of the ``Iterator`` template parameter should
--itself be dereferenceable. The return type of the ``operator*`` for
--the ``value_type`` must be the same type as the ``Reference`` template
--parameter. The ``Value`` template parameter will be the ``value_type``
--for the ``indirect_iterator``, unless ``Value`` is const. If ``Value``
--is ``const X``, then ``value_type`` will be *non-* ``const X``.  The
--default for ``Value`` is
-+The expression ``*v``, where ``v`` is an object of
-+``iterator_traits<Iterator>::value_type``, shall be valid
-+expression and convertible to ``reference``.  ``Iterator`` shall
-+model the traversal concept indicated by ``iterator_category``.
-+``Value``, ``Reference``, and ``Difference`` shall be chosen so
-+that ``value_type``, ``reference``, and ``difference_type`` meet
-+the requirements indicated by ``iterator_category``.
- 
--::
-+[Note: there are further requirements on the
-+``iterator_traits<Iterator>::value_type`` if the ``Value``
-+parameter is not ``use_default``, as implied by the algorithm for
-+deducing the default for the ``value_type`` member.]
- 
--  iterator_traits< iterator_traits<Iterator>::value_type >::value_type
-
-Issue 9.37x
-
-+``indirect_iterator`` models
-+............................
- 
--If the default is used for ``Value``, then there must be a valid
--specialization of ``iterator_traits`` for the value type of the base
--iterator.
-+In addition to the concepts indicated by ``iterator_category``
-+and by ``iterator_traversal<indirect_iterator>::type``, a
-+specialization of ``indirect_iterator`` models the following
-+concepts, Where ``v`` is an object of
-+``iterator_traits<Iterator>::value_type``:
- 
--The ``Reference`` parameter will be the ``reference`` type of the
--``indirect_iterator``. The default is ``Value&``.
-+  * Readable Iterator if ``reference(*v)`` is convertible to
-+    ``value_type``.
- 
--The ``Access`` and ``Traversal`` parameters are passed unchanged to
--the corresponding parameters of the ``iterator_adaptor`` base
--class, and  the ``Iterator`` parameter is passed unchanged as the
--``Base`` parameter to the ``iterator_adaptor`` base class.
-+  * Writable Iterator if ``reference(*v) = t`` is a valid
-+    expression (where ``t`` is an object of type
-+    ``indirect_iterator::value_type``)
- 
--The indirect iterator will model the most refined standard traversal
--concept that is modeled by the ``Iterator`` type.  The indirect
--iterator will model the most refined standard access concept that is
--modeled by the value type of ``Iterator``.
-+  * Lvalue Iterator if ``reference`` is a reference type.
-+
-+``indirect_iterator<X,V1,C1,R1,D1>`` is interoperable with
-+``indirect_iterator<Y,V2,C2,R2,D2>`` if and only if ``X`` is
-+interoperable with ``Y``.
- 
- 
- ``indirect_iterator`` operations
- ................................
-
-Issue 9.37x
- 
-+In addition to the operations required by the concepts described
-+above, specializations of ``indirect_iterator`` provide the
-+following operations.
-+
-+
-
-Issue 9.28 and 9.37x
-
- ``indirect_iterator();``
- 
- :Requires: ``Iterator`` must be Default Constructible.
- :Returns: An instance of ``indirect_iterator`` with
--    a default constructed base object.
-+   a default-constructed ``m_iterator``.
- 
-
-Issue 9.37x
- 
- ``indirect_iterator(Iterator x);``
- 
- :Returns: An instance of ``indirect_iterator`` with
--    the ``iterator_adaptor`` subobject copy constructed from ``x``.
-+    ``m_iterator`` copy constructed from ``x``.
- 
- ::
- 
-
-Issue 9.29
-
-@@ -94,5 +151,27 @@
-   );
- 
- :Requires: ``Iterator2`` is implicitly convertible to ``Iterator``.
--:Returns: An instance of ``indirect_iterator`` that is a copy of ``y``.
-+:Returns: An instance of ``indirect_iterator`` whose 
-+    ``m_iterator`` subobject is constructed from ``y.base()``.
-+
-
-Issue 9.37x
-
-+``Iterator const& base() const;``
- 
-+:Returns: ``m_iterator``
-+
-+
-+``reference operator*() const;``
-+
-+:Returns:  ``**m_iterator``
-+
-+
-+``indirect_iterator& operator++();``
-+
-+:Effects: ``++m_iterator``
-+:Returns: ``*this``
-+
-+
-+``indirect_iterator& operator--();``
-+
-+:Effects: ``--m_iterator``
-+:Returns: ``*this``

doc/indirect_iterator_ref.html

@@ -1,147 +0,0 @@
-<?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.2.8: http://docutils.sourceforge.net/" />
-<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
-    );
-};
-</pre>
-<p>The member types of <tt class="literal"><span class="pre">indirect_iterator</span></tt> are defined according to the
-following pseudo-code.  We use the abbreviation
-<tt class="literal"><span class="pre">V=iterator_traits&lt;Iterator&gt;::value_type</span></tt> and <tt class="literal"><span class="pre">v</span></tt> is an object of
-type <tt class="literal"><span class="pre">V</span></tt>.:</p>
-<pre class="literal-block">
-if (Value is use_default) then
-    typedef iterator_traits&lt;V&gt;::value_type value_type;
-else
-    typedef remove_const&lt;Value&gt;::type value_type;
-
-if (Reference is use_default) then
-    typedef iterator_traits&lt;V&gt;::reference reference;
-else
-    typedef Reference reference;
-
-typedef Value* pointer;
-
-if (Difference is use_default)
-    typedef iterator_traits&lt;Iterator&gt;::difference_type difference_type;
-else
-    typedef Difference difference_type;
-</pre>
-<p>The member <tt class="literal"><span class="pre">indirect_iterator::iterator_category</span></tt> is a type that
-satisfies the requirements of the concepts modeled by the indirect
-iterator as specified in the models section.</p>
-<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 <tt class="literal"><span class="pre">Iterator</span></tt> argument shall meet the requirements of Readable
-Iterator. The <tt class="literal"><span class="pre">CategoryOrTraversal</span></tt> argument shall be one of the
-standard iterator tags or <tt class="literal"><span class="pre">use_default</span></tt>. If <tt class="literal"><span class="pre">CategoryOrTraversal</span></tt>
-is an iterator tag, the template parameter <tt class="literal"><span class="pre">Iterator</span></tt> argument shall
-meet the traversal requirements corresponding to the iterator tag.</p>
-<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 type
-<tt class="literal"><span class="pre">iterator_traits&lt;Iterator&gt;::value_type</span></tt>, must be a valid expression
-and must be convertible to <tt class="literal"><span class="pre">indirect_iterator::reference</span></tt>.  Also,
-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>If <tt class="literal"><span class="pre">CategoryOrTraversal</span></tt> is a standard iterator tag,
-<tt class="literal"><span class="pre">indirect_iterator</span></tt> is a model of the iterator concept corresponding
-to the tag, otherwise <tt class="literal"><span class="pre">indirect_iterator</span></tt> satisfies the requirements
-of the most refined standard traversal concept that is satisfied by
-the <tt class="literal"><span class="pre">Iterator</span></tt> argument.</p>
-<p><tt class="literal"><span class="pre">indirect_iterator</span></tt> models Readable Iterator.  If
-<tt class="literal"><span class="pre">indirect_iterator::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>) then
-<tt class="literal"><span class="pre">indirect_iterator</span></tt> models Writable Iterator. If
-<tt class="literal"><span class="pre">indirect_iterator::reference</span></tt> is a reference then
-<tt class="literal"><span class="pre">indirect_iterator</span></tt> models Lvalue Iterator.</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><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">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">indirect_iterator</span></tt> with 
-a default-constructed <tt class="literal"><span class="pre">iterator_adaptor</span></tt> subobject.</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">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">indirect_iterator</span></tt> with
-the <tt class="literal"><span class="pre">iterator_adaptor</span></tt> subobject 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">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">indirect_iterator</span></tt> whose 
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt> subobject is constructed from <tt class="literal"><span class="pre">y.base()</span></tt>.</td>
-</tr>
-</tbody>
-</table>
-</div>
-</div>
-</body>
-</html>

doc/indirect_iterator_ref.rst

@@ -1,177 +0,0 @@
-::
-
-  template <
-      class Iterator
-    , class Value = use_default
-    , class CategoryOrTraversal = use_default
-    , class Reference = use_default
-    , class Difference = use_default
-  >
-  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 <
-          class Iterator2, class Value2, class Category2
-        , class Reference2, class Difference2
-      >
-      indirect_iterator(
-          indirect_iterator<
-               Iterator2, Value2, Category2, Reference2, Difference2
-          > const& y
-        , typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
-      );
-
-      Iterator const& base() const;
-      reference operator*() const;
-      indirect_iterator& operator++();
-      indirect_iterator& operator--();
-  private:
-     Iterator m_iterator; // exposition
-  };
-
-
-The member types of ``indirect_iterator`` are defined according to
-the following pseudo-code, where ``V`` is
-``iterator_traits<Iterator>::value_type``
-
-.. parsed-literal::
-
-  if (Value is use_default) then
-      typedef remove_const<pointee<V>::type>::type value_type;
-  else
-      typedef remove_const<Value>::type value_type;
-
-  if (Reference is use_default) then
-      if (Value is use_default) then
-          typedef indirect_reference<V>::type reference;
-      else
-          typedef Value& reference;
-  else
-      typedef Reference reference;
-
-  if (Value is use_default) then 
-      typedef pointee<V>::type\* pointer;
-  else 
-      typedef Value\* pointer;
-
-  if (Difference is use_default)
-      typedef iterator_traits<Iterator>::difference_type difference_type;
-  else
-      typedef Difference difference_type;
-
-  if (CategoryOrTraversal is use_default)
-      typedef *iterator-category* (
-          iterator_traversal<Iterator>::type,``reference``,``value_type``
-      ) iterator_category;
-  else
-      typedef *iterator-category* (
-          CategoryOrTraversal,``reference``,``value_type``
-      ) iterator_category;
-
-
-``indirect_iterator`` requirements
-..................................
-
-The expression ``*v``, where ``v`` is an object of
-``iterator_traits<Iterator>::value_type``, shall be valid
-expression and convertible to ``reference``.  ``Iterator`` shall
-model the traversal concept indicated by ``iterator_category``.
-``Value``, ``Reference``, and ``Difference`` shall be chosen so
-that ``value_type``, ``reference``, and ``difference_type`` meet
-the requirements indicated by ``iterator_category``.
-
-[Note: there are further requirements on the
-``iterator_traits<Iterator>::value_type`` if the ``Value``
-parameter is not ``use_default``, as implied by the algorithm for
-deducing the default for the ``value_type`` member.]
-
-``indirect_iterator`` models
-............................
-
-In addition to the concepts indicated by ``iterator_category``
-and by ``iterator_traversal<indirect_iterator>::type``, a
-specialization of ``indirect_iterator`` models the following
-concepts, Where ``v`` is an object of
-``iterator_traits<Iterator>::value_type``:
-
-  * Readable Iterator if ``reference(*v)`` is convertible to
-    ``value_type``.
-   
-  * Writable Iterator if ``reference(*v) = t`` is a valid
-    expression (where ``t`` is an object of type
-    ``indirect_iterator::value_type``)
-
-  * Lvalue Iterator if ``reference`` is a reference type.
-
-``indirect_iterator<X,V1,C1,R1,D1>`` is interoperable with
-``indirect_iterator<Y,V2,C2,R2,D2>`` if and only if ``X`` is
-interoperable with ``Y``.
-
-
-``indirect_iterator`` operations
-................................
-
-In addition to the operations required by the concepts described
-above, specializations of ``indirect_iterator`` provide the
-following operations.
-
-
-``indirect_iterator();``
-
-:Requires: ``Iterator`` must be Default Constructible.
-:Effects: Constructs an instance of ``indirect_iterator`` with 
-   a default-constructed ``m_iterator``.
-
-
-``indirect_iterator(Iterator x);``
-
-:Effects: Constructs an instance of ``indirect_iterator`` with
-    ``m_iterator`` copy constructed from ``x``.
-
-::
-
-  template <
-      class Iterator2, class Value2, unsigned Access, class Traversal
-    , class Reference2, class Difference2
-  >
-  indirect_iterator(
-      indirect_iterator<
-           Iterator2, Value2, Access, Traversal, Reference2, Difference2
-      > const& y
-    , typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
-  );
-
-:Requires: ``Iterator2`` is implicitly convertible to ``Iterator``.
-:Effects: Constructs an instance of ``indirect_iterator`` whose 
-    ``m_iterator`` subobject is constructed from ``y.base()``.
-
-
-``Iterator const& base() const;``
-
-:Returns: ``m_iterator``
-
-
-``reference operator*() const;``
-
-:Returns:  ``**m_iterator``
-
-
-``indirect_iterator& operator++();``
-
-:Effects: ``++m_iterator``
-:Returns: ``*this``
-
-
-``indirect_iterator& operator--();``
-
-:Effects: ``--m_iterator``
-:Returns: ``*this``

doc/indirect_reference_ref.rst

@@ -1,29 +0,0 @@
-.. 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)
-
-::
-
-  template <class Dereferenceable>
-  struct indirect_reference
-  {
-      typedef /* see below */ type;
-  };
-
-:Requires: For an object ``x`` of type ``Dereferenceable``, ``*x``
-  is well-formed.  If ``++x`` is ill-formed it shall neither be
-  ambiguous nor shall it violate access control, and
-  ``pointee<Dereferenceable>::type&`` shall be well-formed.
-  Otherwise ``iterator_traits<Dereferenceable>::reference`` shall
-  be well formed.  [Note: These requirements need not apply to
-  explicit or partial specializations of ``indirect_reference``]
-
-``type`` is determined according to the following algorithm, where
-``x`` is an object of type ``Dereferenceable``::
-
-  if ( ++x is ill-formed )
-      return ``pointee<Dereferenceable>::type&``
-  else
-      std::iterator_traits<Dereferenceable>::reference
-
-  

doc/interoperability-revisited.rst

@@ -1,232 +0,0 @@
-++++++++++++++++++++++++++++
- Interoperability Revisited 
-++++++++++++++++++++++++++++
-
-:date: $Date$
-:copyright: Copyright Thomas Witt 2004.
-
-
-Problem
-=======
-
-The current iterator_facade specification makes it unneccessarily tedious to
-implement interoperable iterators.
-
-In the following text a simplified example of the current iterator_facade specification is used to
-illustrate the problem.
-
-In the current specification binary operators are implemented in the following way:
-
-template <class Derived>
-struct Facade
-{
-};
-
-template <class T1, T2>
-struct is_interoperable :
-  or_< 
-       is_convertible<T1, T2>
-     , is_convertible<T2, T1>
-  > 
-{};
-
-template<
-    class Derived1
-  , class Derived2
->
-enable_if<is_interoperable<Derived1, Derived2>, bool> operator==(
-    Derived1 const& lhs
-  , Derived2 const& rhs
-)
-{
-  return static_cast<Derived1 const&>(lhs).equal_to(static_cast<Derived2 const&(rhs));
-} 
-
-The problem with this is that operator== always forwards to Derived1::equal_to. The net effect is that the
-following "obvious" implementation of to interoperable types does not quite work.
-
-struct Mutable : Facade<Mutable>
-{
-  bool equal_to(Mutable const&);  
-};
-
-struct Constant : Facade<Constant>
-{
-  Constant();
-  Constant(Constant const&);
-  Constant(Mutable const&);
- 
-  ...
-
-  bool equal_to(Constant const&);  
-};
-
-Constant c;
-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
-
-struct Mutable : Facade<Mutable>
-{
-  template <class T>
-  enable_if<is_convertible<Mutable, T> || is_convertible<T, Mutable>, bool>::type equal_to(T const&);  
-};
-
-struct Constant : Tag<Constant>
-{
-  Constant();
-  Constant(Constant const&);
-  Constant(Mutable const&);
-
-  template <class T>
-  enable_if<is_convertible<Constant, T> || is_convertible<T, Constant>, bool>::type equal_to(T const&);  
-};
-
-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
-Mutable or Constant. Would Mutable be defined as  
-
-struct Mutable : Facade<Mutable>
-{
-  bool equal_to(Mutable const&);  
-  bool equal_to(Constant const&);  
-};
-
-Constant and Mutable would still be interoperable but no further interoperable could be added 
-without changing Mutable. Even if this would be considered acceptable the current specification forces
-a two way dependency between interoperable types. Note in the templated equal_to case this dependency 
-is implicitly created when specializing equal_to.
-
-Solution
-========
-
-The two way dependency can be avoided by enabling type conversion in the binary operator
-implementation. Note that this is the usual way interoperability betwween types is achieved
-for binary operators and one reason why binary operators are usually implemented as non-members.
-
-A simple implementation of this strategy would look like this
-
-template<
-    class T1
-  , class T2
->
-struct interoperable_base :
-    if_< 
-        is_convertible<
-            T2
-          , T1
-        >
-      , T1
-      , T2>
-{};
-
-
-template<
-    class Derived1
-  , class Derived2
->
-enable_if<is_interoperable<Derived1, Derived2>, bool> operator==(
-    Derived1 const& lhs
-  , Derived2 const& rhs
-)
-{
-  typedef interoperable_base<
-              Derived1
-            , Derived2
-          >::type Base;
-
-  return static_cast<Base const&>(lhs).equal_to(static_cast<Derived2 const&(rhs));
-} 
-
-This way our original simple and "obvious" implementation would work again.
-
-c == m; // ok, dispatched to Constant::equal_to
-m == c; // ok, dispatched to Constant::equal_to, m converted to Constant
-
-The backdraw of this approach is that a possibly costly conversion of iterator objects
-is forced on the user even in cases where direct comparison could be implemented
-in a much more efficient way. This problem arises especially for iterator_adaptor
-specializations and can be significantly slow down the iteration over ranges. Given the fact
-that iteration is a very basic operation this possible performance degradation is not 
-acceptable.
-
-Luckily whe can have our cake and eat it by a slightly more clever implementation of the binary 
-operators.
-
-template<
-    class Derived1
-  , class Derived2
->
-enable_if<is_convertible<Derived2, Derived1>, bool> operator==(
-    Derived1 const& lhs
-  , Derived2 const& rhs
-)
-{
-  return static_cast<Derived1 const&>(lhs).equal_to(static_cast<Derived2 const&(rhs));
-} 
-
-template<
-    class Derived1
-  , class Derived2
->
-enable_if<is_convertible<Derived1, Derived2>, bool> operator==(
-    Derived1 const& lhs
-  , Derived2 const& rhs
-)
-{
-  return static_cast<Derived2 const&>(rhs).equal_to(static_cast<Derived1 const&(lhs));
-} 
-
-Given our simple and obvious definition of Mutable and Constant nothing has changed yet. 
-
-c == m; // ok, dispatched to Constant::equal_to, m converted to Constant
-m == c; // ok, dispatched to Constant::equal_to, m converted to Constant
-
-But now the user can avoid the type conversion by supplying the appropriate overload in Constant
-
-struct Constant : Facade<Constant>
-{
-  Constant();
-  Constant(Constant const&);
-  Constant(Mutable const&);
- 
-  ...
-
-  bool equal_to(Constant const&);  
-  bool equal_to(Mutable const&);  
-};
-
-c == m; // ok, dispatched to Constant::equal_to(Mutable const&), no conversion
-m == c; // ok, dispatched to Constant::equal_to(Mutable const&), no conversion
-
-This definition of operator== introduces a possible ambiguity when both types are convertible
-to each other. I don't think this is a problem as this behaviour is the same with concrete types.
-I.e. 
-
-struct A {};
-
-bool operator==(A, A);
-
-struct B { B(A); }; 
-
-bool operator==(B, B);
-
-A a;
-B b(a);
-
-a == b; // error, ambiguous overload
-
-Effect
-======
-
-Iterator implementations using iterator_facade look exactly as if they were
-"hand-implemented" (I am working on better wording).
-
-a) Less burden for the user
-
-b) The definition (standardese) of specialized adpters might be easier 
-   (This has to be proved yet)

doc/issues.html

@@ -1,165 +0,0 @@
-<?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.2.8: 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>
-<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="contents topic" id="table-of-contents">
-<p class="topic-title"><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>
-<li><a class="reference" href="#rationale" id="id3" name="id3">Rationale</a></li>
-</ul>
-</div>
-<div class="section" id="introduction">
-<h1><a class="toc-backref" href="#id1" name="introduction">Introduction</a></h1>
-<p>The <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> traits classes in <a class="reference" href="http://www.boost-consulting.com/writing/n1550.html">N1550</a>
-provide a mechanism for determining at compile time if an iterator
-type is a model of the new Writable Iterator and Swappable Iterator
-concepts, analogous to <tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::iterator_category</span></tt>
-for the old iterator concepts. For backward compatibility,
-<tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> not only work with new
-iterators, but they also are intended to work for old
-iterators (iterators that meet the requirements for one of the
-iterator concepts in the current standard). In the case of old
-iterators, the writability and swapability is deduced based on the
-<tt class="literal"><span class="pre">iterator_category</span></tt> and also the <tt class="literal"><span class="pre">reference</span></tt> type. The
-specification for this deduction gives false positives for forward
-iterators that have non-assignable value types.</p>
-<p>To review, the part of the <tt class="literal"><span class="pre">is_writable</span></tt> trait definition which
-applies to old iterators is:</p>
-<pre class="literal-block">
-if (cat is convertible to output_iterator_tag)
-    return true;
-else if (cat is convertible to forward_iterator_tag
-         and iterator_traits&lt;Iterator&gt;::reference is a 
-             mutable reference)
-    return true;
-else
-    return false;
-</pre>
-<p>Suppose the <tt class="literal"><span class="pre">value_type</span></tt> of the iterator <tt class="literal"><span class="pre">It</span></tt> has a private
-assignment operator:</p>
-<pre class="literal-block">
-class B {
-public:
-  ...
-private:
-  B&amp; operator=(const B&amp;);
-};
-</pre>
-<p>and suppose the <tt class="literal"><span class="pre">reference</span></tt> type of the iterator is <tt class="literal"><span class="pre">B&amp;</span></tt>.  In
-that case, <tt class="literal"><span class="pre">is_writable&lt;It&gt;::value</span></tt> will be true when in fact
-attempting to write into <tt class="literal"><span class="pre">B</span></tt> will cause an error.</p>
-<p>The same problem applies to <tt class="literal"><span class="pre">is_swappable</span></tt>.</p>
-</div>
-<div class="section" id="proposed-resolution">
-<h1><a class="toc-backref" href="#id2" name="proposed-resolution">Proposed Resolution</a></h1>
-<ol class="arabic">
-<li><p class="first">Remove the <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> traits, and remove the
-requirements in the Writable Iterator and Swappable Iterator concepts
-that require their models to support these traits.</p>
-</li>
-<li><p class="first">Change the <tt class="literal"><span class="pre">is_readable</span></tt> specification to be:
-<tt class="literal"><span class="pre">is_readable&lt;X&gt;::type</span></tt> is <tt class="literal"><span class="pre">true_type</span></tt> if the
-result type of <tt class="literal"><span class="pre">X::operator*</span></tt> is convertible to
-<tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::value_type</span></tt> and is <tt class="literal"><span class="pre">false_type</span></tt>
-otherwise. Also, <tt class="literal"><span class="pre">is_readable</span></tt> is required to satisfy
-the requirements for the UnaryTypeTrait concept
-(defined in the type traits proposal).</p>
-<p>Remove the requirement for support of the <tt class="literal"><span class="pre">is_readable</span></tt> trait from
-the Readable Iterator concept.</p>
-</li>
-<li><p class="first">Remove the <tt class="literal"><span class="pre">iterator_tag</span></tt> class.</p>
-</li>
-<li><p class="first">Change the specification of <tt class="literal"><span class="pre">traversal_category</span></tt> to:</p>
-<pre class="literal-block">
-traversal-category(Iterator) =
-    let cat = iterator_traits&lt;Iterator&gt;::iterator_category
-    if (cat is convertible to incrementable_iterator_tag)
-      return cat; // Iterator is a new iterator
-    else if (cat is convertible to random_access_iterator_tag)
-        return random_access_traversal_tag;
-    else if (cat is convertible to bidirectional_iterator_tag)
-        return bidirectional_traversal_tag;
-    else if (cat is convertible to forward_iterator_tag)
-        return forward_traversal_tag;
-    else if (cat is convertible to input_iterator_tag)
-        return single_pass_iterator_tag;
-    else if (cat is convertible to output_iterator_tag)
-        return incrementable_iterator_tag;
-    else
-        return null_category_tag;
-</pre>
-</li>
-</ol>
-</div>
-<div class="section" id="rationale">
-<h1><a class="toc-backref" href="#id3" name="rationale">Rationale</a></h1>
-<ol class="arabic simple">
-<li>There are two reasons for removing <tt class="literal"><span class="pre">is_writable</span></tt>
-and <tt class="literal"><span class="pre">is_swappable</span></tt>. The first is that we do not know of
-a way to fix the specification so that it gives the correct
-answer for all iterators. Second, there was only a weak
-motivation for having <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt>
-there in the first place.  The main motivation was simply
-uniformity: we have tags for the old iterator categories
-so we should have tags for the new iterator categories.
-While having tags and the capability to dispatch based
-on the traversal categories is often used, we see
-less of a need for dispatching based on writability
-and swappability, since typically algorithms
-that need these capabilities have no alternative if
-they are not provided.</li>
-<li>We discovered that the <tt class="literal"><span class="pre">is_readable</span></tt> trait can be implemented
-using only the iterator type itself and its <tt class="literal"><span class="pre">value_type</span></tt>.
-Therefore we remove the requirement for <tt class="literal"><span class="pre">is_readable</span></tt> from the
-Readable Iterator concept, and change the definition of
-<tt class="literal"><span class="pre">is_readable</span></tt> so that it works for any iterator type.</li>
-<li>The purpose of the <tt class="literal"><span class="pre">iterator_tag</span></tt> class was to
-bundle the traversal and access category tags
-into the <tt class="literal"><span class="pre">iterator_category</span></tt> typedef.
-With <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> gone, and
-<tt class="literal"><span class="pre">is_readable</span></tt> no longer in need of special hints,
-there is no reason for iterators to provide
-information about the access capabilities of an iterator.
-Thus there is no need for the <tt class="literal"><span class="pre">iterator_tag</span></tt>. The
-traversal tag can be directly used for the
-<tt class="literal"><span class="pre">iterator_category</span></tt>. If a new iterator is intended to be backward
-compatible with old iterator concepts, a tag type
-that is convertible to both one of the new traversal tags 
-and also to an old iterator tag can be created and use
-for the <tt class="literal"><span class="pre">iterator_category</span></tt>.</li>
-<li>The changes to the specification of <tt class="literal"><span class="pre">traversal_category</span></tt> are a 
-direct result of the removal of <tt class="literal"><span class="pre">iterator_tag</span></tt>.</li>
-</ol>
-</div>
-</div>
-</body>
-</html>

doc/issues.rst

@@ -1,152 +0,0 @@
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- Problem with ``is_writable`` and ``is_swappable`` in N1550_
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-.. _N1550: http://www.boost-consulting.com/writing/n1550.html
-.. _N1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html
-
-:Author: David Abrahams and Jeremy Siek
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu
-:Organization: `Boost Consulting`_, Indiana University Bloomington
-:date: $Date$
-:Copyright: 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 http://www.boost.org/LICENSE_1_0.txt)
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-
-.. contents:: Table of Contents
-
-==============
- Introduction
-==============
-
-The ``is_writable`` and ``is_swappable`` traits classes in N1550_
-provide a mechanism for determining at compile time if an iterator
-type is a model of the new Writable Iterator and Swappable Iterator
-concepts, analogous to ``iterator_traits<X>::iterator_category``
-for the old iterator concepts. For backward compatibility,
-``is_writable`` and ``is_swappable`` not only work with new
-iterators, but they also are intended to work for old
-iterators (iterators that meet the requirements for one of the
-iterator concepts in the current standard). In the case of old
-iterators, the writability and swapability is deduced based on the
-``iterator_category`` and also the ``reference`` type. The
-specification for this deduction gives false positives for forward
-iterators that have non-assignable value types.
-
-To review, the part of the ``is_writable`` trait definition which
-applies to old iterators is::
-
-  if (cat is convertible to output_iterator_tag)
-      return true;
-  else if (cat is convertible to forward_iterator_tag
-           and iterator_traits<Iterator>::reference is a 
-               mutable reference)
-      return true;
-  else
-      return false;
-
-Suppose the ``value_type`` of the iterator ``It`` has a private
-assignment operator::
-
-  class B {
-  public:
-    ...
-  private:
-    B& operator=(const B&);
-  };
-
-and suppose the ``reference`` type of the iterator is ``B&``.  In
-that case, ``is_writable<It>::value`` will be true when in fact
-attempting to write into ``B`` will cause an error.
-
-The same problem applies to ``is_swappable``.
-
-
-====================
- Proposed Resolution
-====================
-
-1. Remove the ``is_writable`` and ``is_swappable`` traits, and remove the
-   requirements in the Writable Iterator and Swappable Iterator concepts
-   that require their models to support these traits.
-
-2. Change the ``is_readable`` specification to be:
-   ``is_readable<X>::type`` is ``true_type`` if the
-   result type of ``X::operator*`` is convertible to
-   ``iterator_traits<X>::value_type`` and is ``false_type``
-   otherwise. Also, ``is_readable`` is required to satisfy
-   the requirements for the UnaryTypeTrait concept
-   (defined in the type traits proposal).
-   
-   Remove the requirement for support of the ``is_readable`` trait from
-   the Readable Iterator concept.
-
-
-3. Remove the ``iterator_tag`` class.
-
-4. Change the specification of ``traversal_category`` to::
-
-    traversal-category(Iterator) =
-        let cat = iterator_traits<Iterator>::iterator_category
-        if (cat is convertible to incrementable_iterator_tag)
-          return cat; // Iterator is a new iterator
-        else if (cat is convertible to random_access_iterator_tag)
-            return random_access_traversal_tag;
-        else if (cat is convertible to bidirectional_iterator_tag)
-            return bidirectional_traversal_tag;
-        else if (cat is convertible to forward_iterator_tag)
-            return forward_traversal_tag;
-        else if (cat is convertible to input_iterator_tag)
-            return single_pass_iterator_tag;
-        else if (cat is convertible to output_iterator_tag)
-            return incrementable_iterator_tag;
-        else
-            return null_category_tag;
-
-
-==========
- Rationale
-==========
-
-1. There are two reasons for removing ``is_writable``
-   and ``is_swappable``. The first is that we do not know of
-   a way to fix the specification so that it gives the correct
-   answer for all iterators. Second, there was only a weak
-   motivation for having ``is_writable`` and ``is_swappable``
-   there in the first place.  The main motivation was simply
-   uniformity: we have tags for the old iterator categories
-   so we should have tags for the new iterator categories.
-   While having tags and the capability to dispatch based
-   on the traversal categories is often used, we see
-   less of a need for dispatching based on writability
-   and swappability, since typically algorithms
-   that need these capabilities have no alternative if
-   they are not provided.
-
-2. We discovered that the ``is_readable`` trait can be implemented
-   using only the iterator type itself and its ``value_type``.
-   Therefore we remove the requirement for ``is_readable`` from the
-   Readable Iterator concept, and change the definition of
-   ``is_readable`` so that it works for any iterator type.
-
-3. The purpose of the ``iterator_tag`` class was to
-   bundle the traversal and access category tags
-   into the ``iterator_category`` typedef.
-   With ``is_writable`` and ``is_swappable`` gone, and
-   ``is_readable`` no longer in need of special hints,
-   there is no reason for iterators to provide
-   information about the access capabilities of an iterator.
-   Thus there is no need for the ``iterator_tag``. The
-   traversal tag can be directly used for the
-   ``iterator_category``. If a new iterator is intended to be backward
-   compatible with old iterator concepts, a tag type
-   that is convertible to both one of the new traversal tags 
-   and also to an old iterator tag can be created and use
-   for the ``iterator_category``.
-
-4. The changes to the specification of ``traversal_category`` are a 
-   direct result of the removal of ``iterator_tag``.
-

doc/iterator_adaptor.html

@@ -1,450 +0,0 @@
-<?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.4: 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" />
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<h1 class="title">Iterator Adaptor</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;ive.uni-hannover.de">witt&#64;ive.uni-hannover.de</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>, 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>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved</td></tr>
-</tbody>
-</table>
-<div class="document" id="iterator-adaptor">
-<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">abstract:</th><td class="field-body"></td>
-</tr>
-</tbody>
-</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.
-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>
-<div class="contents topic" id="table-of-contents">
-<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>
-</ul>
-</li>
-<li><a class="reference" href="#tutorial-example" id="id13" name="id13">Tutorial Example</a></li>
-</ul>
-</div>
-<div class="section" id="overview">
-<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">
-<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>
-</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
-<tt class="literal"><span class="pre">iterator_facade</span></tt> core requirements table. 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
-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>
-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
-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. -->
-<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">
-<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>
-<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>
-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">
-<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">
-<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">
-<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">
-<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">
-<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">
-<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>
-<div class="section" id="tutorial-example">
-<h1><a class="toc-backref" href="#id13" name="tutorial-example">Tutorial Example</a></h1>
-<!-- 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
-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 first"><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
-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
-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
-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 that underlies <tt class="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>).  The only real behavioral difference
-between <tt class="literal"><span class="pre">node_base*</span></tt> and <tt class="literal"><span class="pre">node_iterator</span></tt> can be observed when
-they are incremented: <tt class="literal"><span class="pre">node_iterator</span></tt> follows the
-<tt class="literal"><span class="pre">m_next</span></tt> pointer, while <tt class="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
-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>
-<pre class="literal-block">
-template &lt;class Value&gt;
-class node_iter
-  : public boost::iterator_adaptor&lt;
-        node_iter&lt;Value&gt;                // Derived
-      , Value*                          // Base
-      , boost::use_default              // Value
-      , boost::forward_traversal_tag    // CategoryOrTraversal
-    &gt;
-{
- private:
-    struct enabler {};  // a private type avoids misuse
-
- public:
-    node_iter()
-      : node_iter::iterator_adaptor_(0) {}
-
-    explicit node_iter(Value* p)
-      : node_iter::iterator_adaptor_(p) {}
-
-    template &lt;class OtherValue&gt;
-    node_iter(
-        node_iter&lt;OtherValue&gt; const&amp; other
-      , typename boost::enable_if&lt;
-            boost::is_convertible&lt;OtherValue*,Value*&gt;
-          , enabler
-        &gt;::type = enabler()
-    )
-      : 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>Note the use of <tt class="literal"><span class="pre">node_iter::iterator_adaptor_</span></tt> here: because
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt> defines a nested <tt class="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="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
-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
-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>
-<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
-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>
-</div>
-</div>
-<hr class="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

@@ -1,37 +0,0 @@
-+++++++++++++++++
- Iterator Adaptor
-+++++++++++++++++
-
-:Author: David Abrahams, Jeremy Siek, Thomas Witt
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@ive.uni-hannover.de
-:organization: `Boost Consulting`_, Indiana University `Open Systems
-               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
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-.. _`Open Systems Lab`: http://www.osl.iu.edu
-.. _`Institute for Transport Railway Operation and Construction`: http://www.ive.uni-hannover.de
-
-:abstract:
-
-.. include:: iterator_adaptor_abstract.rst
-
-.. contents:: Table of Contents
-
-Overview
-========
-
-.. include:: iterator_adaptor_body.rst
-
-
-Reference
-=========
-
-.. include:: iterator_adaptor_ref.rst
-
-Tutorial Example
-================
-
-.. include:: iterator_adaptor_tutorial.rst

doc/iterator_adaptor_abstract.diff

@@ -1,22 +0,0 @@
-Index: iterator_adaptor_abstract.rst
-===================================================================
-RCS file: /cvsroot/boost/boost/libs/iterator/doc/iterator_adaptor_abstract.rst,v
-retrieving revision 1.1
-retrieving revision 1.2
-diff -b -d -u -r1.1 -r1.2
---- iterator_adaptor_abstract.rst	5 Aug 2003 18:19:55 -0000	1.1
-+++ iterator_adaptor_abstract.rst	24 Nov 2003 05:02:46 -0000	1.2
-@@ -1,5 +1,11 @@  Issue 9.21
--The ``iterator_adaptor`` is a base class template derived from an
--instantiation of ``iterator_facade``. The core interface functions
-+.. 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
-+
-+Each specialization of the ``iterator_adaptor`` class template is derived from
-+a specialization of ``iterator_facade``. The core interface functions
- expected by ``iterator_facade`` are implemented in terms of the
- ``iterator_adaptor``\ 's ``Base`` template parameter. A class derived
- from ``iterator_adaptor`` typically redefines some of the core

doc/iterator_adaptor_abstract.rst

@@ -1,16 +0,0 @@
-.. 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
-
-Each specialization of the ``iterator_adaptor`` class template is derived from
-a specialization of ``iterator_facade``. The core interface functions
-expected by ``iterator_facade`` are implemented in terms of the
-``iterator_adaptor``\ 's ``Base`` template parameter. A class derived
-from ``iterator_adaptor`` typically redefines some of the core
-interface functions to adapt the behavior of the ``Base`` type.
-Whether the derived class models any of the standard iterator concepts
-depends on the operations supported by the ``Base`` type and which
-core interface functions of ``iterator_facade`` are redefined in the
-``Derived`` class.

doc/iterator_adaptor_body.diff

@@ -1,35 +0,0 @@
-Index: iterator_adaptor_body.rst
-===================================================================
-RCS file: /cvsroot/boost/boost/libs/iterator/doc/iterator_adaptor_body.rst,v
-retrieving revision 1.2
-retrieving revision 1.3
-diff -b -d -u -r1.2 -r1.3
---- iterator_adaptor_body.rst	22 Sep 2003 19:55:00 -0000	1.2
-+++ iterator_adaptor_body.rst	24 Nov 2003 05:02:46 -0000	1.3
-@@ -1,3 +1,9 @@
-+.. 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
-+
- The ``iterator_adaptor`` class template adapts some ``Base`` [#base]_
- type to create a new iterator.  Instantiations of ``iterator_adaptor``
- are derived from a corresponding instantiation of ``iterator_facade``
-@@ -19,7 +25,7 @@  Issue 9.1 et al
- redefined in the user's derived class.
- 
- Several of the template parameters of ``iterator_adaptor`` default
--to ``use_default`` (or ``use_default_access``). This allows the
-+to ``use_default``. 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
-@@ -28,6 +34,6 @@  Issue 9.45y
- the identity of the ``use_default`` type is not left unspecified
- because specification helps to highlight that the ``Reference``
- template parameter may not always be identical to the iterator's
--``reference`` type, and will keep users making mistakes based on
-+``reference`` type, and will keep users from making mistakes based on
- that assumption.
- 

doc/iterator_adaptor_body.rst

@@ -1,40 +0,0 @@
-.. 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
-
-The ``iterator_adaptor`` class template adapts some ``Base`` [#base]_
-type to create a new iterator.  Instantiations of ``iterator_adaptor``
-are derived from a corresponding instantiation of ``iterator_facade``
-and implement the core behaviors in terms of the ``Base`` type. In
-essence, ``iterator_adaptor`` merely forwards all operations to an
-instance of the ``Base`` type, which it stores as a member.
-
-.. [#base] The term "Base" 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 ``reverse_iterator`` adaptor.
-
-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
-``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
-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
-``use_default`` can help to simplify the implementation.  Finally,
-the identity of the ``use_default`` type is not left unspecified
-because specification helps to highlight that the ``Reference``
-template parameter may not always be identical to the iterator's
-``reference`` type, and will keep users from making mistakes based on
-that assumption.
-

doc/iterator_adaptor_ref.html

@@ -1,230 +0,0 @@
-<?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.2.8: http://docutils.sourceforge.net/" />
-<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. All
-rights reserved. -->
-<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 base() const;
- protected:
-    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="base-parameters" name="base-parameters"></a><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>
-</div>
-<div class="section" id="iterator-adaptor-usage">
-<h1><a name="iterator-adaptor-usage"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> usage</a></h1>
-<p>The <tt class="literal"><span class="pre">Derived</span></tt> template parameter must be a publicly derived from
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt>.  In order for <tt class="literal"><span class="pre">Derived</span></tt> to model the
-iterator concepts corresponding to
-<tt class="literal"><span class="pre">iterator_traits&lt;Derived&gt;::iterator_category</span></tt>, the expressions
-involving <tt class="literal"><span class="pre">m_iterator</span></tt> in the specifications of those private
-member functions of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> that may be called by
-<tt class="literal"><span class="pre">iterator_facade&lt;Derived,</span> <span class="pre">V,</span> <span class="pre">C,</span> <span class="pre">R,</span> <span class="pre">D&gt;</span></tt>
-in evaluating any valid expression involving <tt class="literal"><span class="pre">Derived</span></tt>
-in those concepts' requirements.</p>
-</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">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 on: 2004-01-12 15:25 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>
-</html>

doc/iterator_adaptor_ref.rst

@@ -1,178 +0,0 @@
-.. 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.
-
-.. parsed-literal::
-  
-  template <
-      class Derived
-    , class Base
-    , class Value               = use_default
-    , class CategoryOrTraversal = use_default
-    , class Reference           = use_default
-    , class Difference = use_default
-  >
-  class iterator_adaptor 
-    : public iterator_facade<Derived, *V'*, *C'*, *R'*, *D'*> // see details__
-  {
-      friend class iterator_core_access;
-   public:
-      iterator_adaptor();
-      explicit iterator_adaptor(Base iter);
-      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.  
-      typename iterator_adaptor::reference dereference() const;
-
-      template <
-      class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
-      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
-  
-      void advance(typename iterator_adaptor::difference_type n);
-      void increment();
-      void decrement();
-
-      template <
-          class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
-      typename iterator_adaptor::difference_type distance_to(
-          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;
-
-   private:
-      Base m_iterator; // exposition only
-  };
-
-__ base_parameters_
-
-.. _requirements:
-
-``iterator_adaptor`` requirements
----------------------------------
-
-``static_cast<Derived*>(iterator_adaptor*)`` shall be well-formed.
-The ``Base`` argument shall be Assignable and Copy Constructible.
-
-
-.. _base_parameters:
-
-``iterator_adaptor`` base class parameters
-------------------------------------------
-
-The *V'*, *C'*, *R'*, and *D'* parameters of the ``iterator_facade``
-used as a base class in the summary of ``iterator_adaptor``
-above are defined as follows:
-
-.. parsed-literal::
-
-   *V'* = if (Value is use_default)
-             return iterator_traits<Base>::value_type
-         else
-             return Value
-
-   *C'* = if (CategoryOrTraversal is use_default)
-             return iterator_traversal<Base>::type
-         else
-             return CategoryOrTraversal
-
-   *R'* = if (Reference is use_default)
-             if (Value is use_default)
-                 return iterator_traits<Base>::reference
-             else
-                 return Value&
-         else
-             return Reference
-
-   *D'* = if (Difference is use_default)
-             return iterator_traits<Base>::difference_type
-         else
-             return Difference
-
-.. ``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?
-
-``iterator_adaptor`` public operations
---------------------------------------
-
-``iterator_adaptor();``
-
-:Requires: The ``Base`` type must be Default Constructible.
-:Returns: An instance of ``iterator_adaptor`` with 
-    ``m_iterator`` default constructed.
-
-
-``explicit iterator_adaptor(Base iter);``
-
-:Returns: An instance of ``iterator_adaptor`` with
-    ``m_iterator`` copy constructed from ``iter``.
-
-``Base const& base() const;``
-
-:Returns: ``m_iterator``
-
-``iterator_adaptor`` protected member functions
------------------------------------------------
-
-``Base const& base_reference() const;``
-
-:Returns: A const reference to ``m_iterator``.
-
-
-``Base& base_reference();``
-
-:Returns: A non-const reference to ``m_iterator``.
-
-
-``iterator_adaptor`` private member functions
----------------------------------------------
-
-``typename iterator_adaptor::reference dereference() const;``
-
-:Returns: ``*m_iterator``
-
-::
-
-  template <
-  class OtherDerived, class OtherIterator, class V, class C, class R, class D
-  >   
-  bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
-
-:Returns: ``m_iterator == x.base()``
-
-
-``void advance(typename iterator_adaptor::difference_type n);``
-
-:Effects: ``m_iterator += n;``
-
-``void increment();``
-
-:Effects: ``++m_iterator;``
-
-``void decrement();``
-
-:Effects: ``--m_iterator;``
-
-::
-
-  template <
-      class OtherDerived, class OtherIterator, class V, class C, class R, class D
-  >   
-  typename iterator_adaptor::difference_type distance_to(
-      iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;
-
-:Returns: ``y.base() - m_iterator``

doc/iterator_adaptor_tutorial.rst

@@ -1,135 +0,0 @@
-.. 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)
-
-In this section we'll further refine the ``node_iter`` class
-template we developed in the |fac_tut|_.  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.
-
-.. |fac_tut| replace:: ``iterator_facade`` tutorial
-.. _fac_tut: iterator_facade.html#tutorial-example
-
-.. sidebar:: ``node_base*`` really *is* an iterator
-
-   It's not really a very interesting iterator, since ``node_base``
-   is an abstract class: a pointer to a ``node_base`` just points
-   at some base subobject of an instance of some other class, and
-   incrementing a ``node_base*`` moves it past this base subobject
-   to who-knows-where?  The most we can do with that incremented
-   position is to compare another ``node_base*`` to it.  In other
-   words, the original iterator traverses a one-element array.
-
-You probably didn't think of it this way, but the ``node_base*``
-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
-of the same associated types (``value_type``, ``reference``,
-``pointer``, and ``difference_type``).  Second, even some of the
-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|_).  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
-
-It turns out that the pattern of building an iterator on another
-iterator-like type (the ``Base`` [#base]_ 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
-``iterator_adaptor``.  Using ``iterator_adaptor`` is very much like
-using ``iterator_facade``, but because iterator_adaptor tries to
-mimic as much of the ``Base`` type's behavior as possible, we
-neither have to supply a ``Value`` argument, nor implement any core
-behaviors other than ``increment``.  The implementation of
-``node_iter`` is thus reduced to::
-
-  template <class Value>
-  class node_iter
-    : public boost::iterator_adaptor<
-          node_iter<Value>                // Derived
-        , Value*                          // Base
-        , boost::use_default              // Value
-        , boost::forward_traversal_tag    // CategoryOrTraversal
-      >
-  {
-   private:
-      struct enabler {};  // a private type avoids misuse
-
-   public:
-      node_iter()
-        : node_iter::iterator_adaptor_(0) {}
-
-      explicit node_iter(Value* p)
-        : node_iter::iterator_adaptor_(p) {}
-
-      template <class OtherValue>
-      node_iter(
-          node_iter<OtherValue> const& other
-        , typename boost::enable_if<
-              boost::is_convertible<OtherValue*,Value*>
-            , enabler
-          >::type = enabler()
-      )
-        : node_iter::iterator_adaptor_(other.base()) {}
-
-   private:
-      friend class boost::iterator_core_access;
-      void increment() { this->base_reference() = this->base()->next(); }
-  };
-
-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
-
-In the case of ``node_iter``, it's not very compelling to pass
-``boost::use_default`` as ``iterator_adaptor``\ 's ``Value``
-argument; we could have just passed ``node_iter``\ 's ``Value``
-along to ``iterator_adaptor``, and that'd even be shorter!  Most
-iterator class templates built with ``iterator_adaptor`` are
-parameterized on another iterator type, rather than on its
-``value_type``.  For example, ``boost::reverse_iterator`` 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, ``iterator_adaptor``\ 's delegation of default
-types to its ``Base`` saves the implementor of
-``boost::reverse_iterator`` from writing:
-
-.. parsed-literal::
-
-   std::iterator_traits<Iterator>::*some-associated-type*
-
-at least four times.  
-
-We urge you to review the documentation and implementations of
-|reverse_iterator|_ and the other Boost `specialized iterator
-adaptors`__ to get an idea of the sorts of things you can do with
-``iterator_adaptor``.  In particular, have a look at
-|transform_iterator|_, which is perhaps the most straightforward
-adaptor, and also |counting_iterator|_, which demonstrates that
-``iterator_adaptor``\ 's ``Base`` type needn't be an iterator.
-
-.. |reverse_iterator| replace:: ``reverse_iterator``
-.. _reverse_iterator: reverse_iterator.html
-
-.. |counting_iterator| replace:: ``counting_iterator``
-.. _counting_iterator: counting_iterator.html
-
-.. |transform_iterator| replace:: ``transform_iterator``
-.. _transform_iterator: transform_iterator.html
-
-__ index.html#specialized-adaptors
-

doc/iterator_archetypes.html

@@ -1,220 +0,0 @@
-<?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.1: 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-27" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. All rights reserved" />
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="iterator-archetype">
-<h1 class="title">Iterator Archetype</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-01-27</td></tr>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. All rights reserved</td></tr>
-</tbody>
-</table>
-<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">abstract:</th><td class="field-body">The <tt class="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="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>
-<ul class="simple">
-<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="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="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="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="literal"><span class="pre">iterator_archetype</span></tt> Models</a></li>
-<li><a class="reference" href="#traits" id="id6" name="id6"><tt class="literal"><span class="pre">Traits</span></tt></a></li>
-</ul>
-</li>
-</ul>
-</div>
-<div class="section" id="reference">
-<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="#id2" name="iterator-archetype-synopsis"><tt class="literal"><span class="pre">iterator_archetype</span></tt> Synopsis</a></h2>
-<pre class="literal-block">
-namespace iterator_archetypes
-{
-    // Access categories
-
-    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;
-
-}
-
-template &lt;
-    class Value
-  , class AccessCategory
-  , class TraversalCategory
-&gt;
-class iterator_archetype
-{
-    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>
-<div class="section" id="access-category-tags">
-<h2><a class="toc-backref" href="#id3" 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>
-<p>The access category types provided correspond to the following
-standard iterator access concept combinations:</p>
-<pre class="literal-block">
-readable_iterator_t :=
-
-  Readable Iterator
-
-writable_iterator_t :=
-
-  Writeable Iterator
-
-readable_writable_iterator_t :=
-
-  Readable Iterator &amp; Writeable Iterator &amp; Swappable Iterator
-
-readable_lvalue_iterator_t :=
-
-  Readable Iterator &amp; Lvalue Iterator
-
-writeable_lvalue_iterator_t :=
-
-  Readable Iterator &amp; Writeable Iterator &amp; Swappable Iterator &amp; Lvalue Iterator
-</pre>
-</div>
-<div class="section" id="iterator-archetype-requirements">
-<h2><a class="toc-backref" href="#id4" 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>
-</div>
-<div class="section" id="iterator-archetype-models">
-<h2><a class="toc-backref" href="#id5" 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
-concepts or any more derived traversal concepts.</p>
-</div>
-<div class="section" id="traits">
-<h2><a class="toc-backref" href="#id6" name="traits"><tt class="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)
-  
-  value_type = Value
-  reference  = Value
-  pointer    = Value*
-
-else if (AccessCategory == writable_iterator_t)
-
-  value_type = void
-  reference  = void
-  pointer    = void
-
-else if (AccessCategory == readable_writable_iterator_t)
-
-  value_type = Value
-
-  reference :=
-
-    A type X that is convertible to Value for which the following
-    expression is valid. Given an object x of type X and v of type 
-    Value.
-
-    x = v
-
-  pointer    = Value*
-
-else if (AccessCategory == readable_lvalue_iterator_t)
-  
-  value_type = Value
-  reference  = Value const&amp;
-  pointer    = Value const*
-
-else if (AccessCategory == writable_lvalue_iterator_t)
-  
-  value_type = Value
-  reference  = Value&amp;
-  pointer    = Value*
-
-if ( TraversalCategory is convertible to forward_traversal_tag )
-
-  difference_type := ptrdiff_t
-
-else
-
-  difference_type := unspecified type
-
-
-iterator_category := 
-
-  A type X satisfying the following two constraints:
-
-     1. X is convertible to X1, and not to any more-derived
-        type, where X1 is defined by:
-
-          if (reference is a reference type
-              &amp;&amp; TraversalCategory is convertible to forward_traversal_tag)
-          {
-              if (TraversalCategory is convertible to random_access_traversal_tag)
-                  X1 = random_access_iterator_tag
-              else if (TraversalCategory is convertible to bidirectional_traversal_tag)
-                  X1 = bidirectional_iterator_tag
-              else
-                  X1 = forward_iterator_tag
-          }
-          else
-          {
-              if (TraversalCategory is convertible to single_pass_traversal_tag
-                  &amp;&amp; reference != void)
-                  X1 = input_iterator_tag
-              else
-                  X1 = output_iterator_tag
-          }
-
-     2. X is convertible to TraversalCategory
-</pre>
-</div>
-</div>
-</div>
-<hr class="footer" />
-<div class="footer">
-<a class="reference" href="iterator_archetypes.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_archetypes.rst

@@ -1,189 +0,0 @@
-++++++++++++++++++++
- Iterator Archetype
-++++++++++++++++++++
-
-: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. All rights reserved
-
-.. _`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_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
-
-Reference
-=========
-
-``iterator_archetype`` Synopsis
-...............................
-
-::
-
-    namespace iterator_archetypes
-    {
-        // Access categories
-
-        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;
-
-    }
-
-    template <
-        class Value
-      , class AccessCategory
-      , class TraversalCategory
-    >
-    class iterator_archetype
-    {
-        typedef /* see below */ value_type;
-        typedef /* see below */ reference;
-        typedef /* see below */ pointer;
-        typedef /* see below */ difference_type;
-        typedef /* see below */ iterator_category;
-    };
-
-``Access Category Tags``
-........................
-
-The access category types provided correspond to the following
-standard iterator access concept combinations:
-
-::
-
-    readable_iterator_t :=
-  
-      Readable Iterator
-
-    writable_iterator_t :=
-  
-      Writeable Iterator
-
-    readable_writable_iterator_t :=
-  
-      Readable Iterator & Writeable Iterator & Swappable Iterator
-
-    readable_lvalue_iterator_t :=
-  
-      Readable Iterator & Lvalue Iterator
-
-    writeable_lvalue_iterator_t :=
-  
-      Readable Iterator & Writeable Iterator & Swappable Iterator & Lvalue Iterator
-
-``iterator_archetype`` Requirements
-...................................
-
-The ``AccessCategory`` argument must be one of the predefined access
-category tags. The ``TraversalCategory`` must be one of the standard
-traversal tags. The ``Value`` type must satisfy the requirements of
-the iterator concept specified by ``AccessCategory`` and
-``TraversalCategory`` as implied by the nested traits types.
-
-``iterator_archetype`` Models
-.............................
-
-``iterator_archetype`` models the iterator concepts specified by the
-``AccessCategory`` and ``TraversalCategory``
-arguments. ``iterator_archetype`` does not model any other access
-concepts or any more derived traversal concepts.
-
-``Traits``
-..........
-
-The nested trait types are defined as follows:
-
-::
-
-   if (AccessCategory == readable_iterator_t)
-     
-     value_type = Value
-     reference  = Value
-     pointer    = Value*
-
-   else if (AccessCategory == writable_iterator_t)
- 
-     value_type = void
-     reference  = void
-     pointer    = void
-
-   else if (AccessCategory == readable_writable_iterator_t)
- 
-     value_type = Value
-
-     reference :=
-
-       A type X that is convertible to Value for which the following
-       expression is valid. Given an object x of type X and v of type 
-       Value.
-
-       x = v
-
-     pointer    = Value*
-
-   else if (AccessCategory == readable_lvalue_iterator_t)
-     
-     value_type = Value
-     reference  = Value const&
-     pointer    = Value const*
-
-   else if (AccessCategory == writable_lvalue_iterator_t)
-     
-     value_type = Value
-     reference  = Value&
-     pointer    = Value*
-
-   if ( TraversalCategory is convertible to forward_traversal_tag )
-
-     difference_type := ptrdiff_t
-
-   else
-  
-     difference_type := unspecified type
-
-   
-   iterator_category := 
-
-     A type X satisfying the following two constraints:
-
-        1. X is convertible to X1, and not to any more-derived
-           type, where X1 is defined by:
-
-             if (reference is a reference type
-                 && TraversalCategory is convertible to forward_traversal_tag)
-             {
-                 if (TraversalCategory is convertible to random_access_traversal_tag)
-                     X1 = random_access_iterator_tag
-                 else if (TraversalCategory is convertible to bidirectional_traversal_tag)
-                     X1 = bidirectional_iterator_tag
-                 else
-                     X1 = forward_iterator_tag
-             }
-             else
-             {
-                 if (TraversalCategory is convertible to single_pass_traversal_tag
-                     && reference != void)
-                     X1 = input_iterator_tag
-                 else
-                     X1 = output_iterator_tag
-             }
-
-        2. X is convertible to TraversalCategory
-
-        

doc/iterator_concepts.html

@@ -1,123 +0,0 @@
-<?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.1: 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-01-27" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. All rights reserved" />
-<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-01-27</td></tr>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. All rights reserved</td></tr>
-</tbody>
-</table>
-<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">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="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="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="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

@@ -1,128 +0,0 @@
-
-
-++++++++++++++++++
- 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. All rights reserved
-
-.. _`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

@@ -1,40 +0,0 @@
-++++++++++++++++
- Iterator Facade
-++++++++++++++++
-
-:Author: David Abrahams, Jeremy Siek, Thomas Witt
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@ive.uni-hannover.de
-:organization: `Boost Consulting`_, Indiana University `Open Systems
-               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
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-.. _`Open Systems Lab`: http://www.osl.iu.edu
-.. _`Institute for Transport Railway Operation and Construction`: http://www.ive.uni-hannover.de
-
-:abstract:
-
-  .. include:: iterator_facade_abstract.rst
-
-.. contents:: Table of Contents
-
-Overview
-========
-
-.. include:: iterator_facade_body.rst
-
-
-Reference
-=========
-
-.. include:: iterator_facade_ref.rst
-
-.. _counting: counting_iterator.html
-
-Tutorial Example
-================
-
-.. include:: iterator_facade_tutorial.rst
-

doc/iterator_facade_abstract.rst

@@ -1,4 +0,0 @@
-``iterator_facade`` is a base class template that implements the
-interface of standard iterators in terms of a few core functions
-and associated types, to be supplied by a derived iterator class.
-

doc/iterator_facade_body.rst

@@ -1,192 +0,0 @@
-.. 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
-
-
-While the iterator interface is rich, there is a core subset of the
-interface that is necessary for all the functionality.  We have
-identified the following core behaviors for iterators:
-
-* dereferencing
-* incrementing
-* decrementing
-* equality comparison
-* random-access motion
-* distance measurement
-
-In addition to the behaviors listed above, the core interface elements
-include the associated types exposed through iterator traits:
-``value_type``, ``reference``, ``difference_type``, and
-``iterator_category``.
-
-Iterator facade uses the Curiously Recurring Template
-Pattern (CRTP) [Cop95]_ so that the user can specify the behavior
-of ``iterator_facade`` in a derived class.  Former designs used
-policy objects to specify the behavior, but that approach was
-discarded for several reasons:
-
-  1. the creation and eventual copying of the policy object may create
-     overhead that can be avoided with the current approach.
-
-  2. The policy object approach does not allow for custom constructors
-     on the created iterator types, an essential feature if
-     ``iterator_facade`` should be used in other library
-     implementations.
-
-  3. Without the use of CRTP, the standard requirement that an
-     iterator's ``operator++`` returns the iterator type itself
-     would mean that all iterators built with the library would
-     have to be specializations of ``iterator_facade<...>``, rather
-     than something more descriptive like
-     ``indirect_iterator<T*>``.  Cumbersome type generator
-     metafunctions would be needed to build new parameterized
-     iterators, and a separate ``iterator_adaptor`` layer would be
-     impossible.
-
-Usage
------
-
-The user of ``iterator_facade`` derives his iterator class from a
-specialization of ``iterator_facade`` and passes the derived
-iterator class as ``iterator_facade``\ 's first template parameter.
-The order of the other template parameters have been carefully
-chosen to take advantage of useful defaults.  For example, when
-defining a constant lvalue iterator, the user can pass a
-const-qualified version of the iterator's ``value_type`` as
-``iterator_facade``\ 's ``Value`` parameter and omit the
-``Reference`` parameter which follows.
-
-The derived iterator class must define member functions implementing
-the iterator's core behaviors.  The following table describes
-expressions which are required to be valid depending on the category
-of the derived iterator type.  These member functions are described
-briefly below and in more detail in the iterator facade
-requirements.
-
-   +------------------------+-------------------------------+
-   |Expression              |Effects                        |
-   +========================+===============================+
-   |``i.dereference()``     |Access the value referred to   |
-   +------------------------+-------------------------------+
-   |``i.equal(j)``          |Compare for equality with ``j``|
-   +------------------------+-------------------------------+
-   |``i.increment()``       |Advance by one position        |
-   +------------------------+-------------------------------+
-   |``i.decrement()``       |Retreat by one position        |
-   +------------------------+-------------------------------+
-   |``i.advance(n)``        |Advance by ``n`` positions     |
-   +------------------------+-------------------------------+
-   |``i.distance_to(j)``    |Measure the distance to ``j``  |
-   +------------------------+-------------------------------+
-
-.. Should we add a comment that a zero overhead implementation of iterator_facade
-   is possible with proper inlining?
-
-In addition to implementing the core interface functions, an iterator
-derived from ``iterator_facade`` typically defines several
-constructors. To model any of the standard iterator concepts, the
-iterator must at least have a copy constructor. Also, if the iterator
-type ``X`` is meant to be automatically interoperate with another
-iterator type ``Y`` (as with constant and mutable iterators) then
-there must be an implicit conversion from ``X`` to ``Y`` or from ``Y``
-to ``X`` (but not both), typically implemented as a conversion
-constructor. Finally, if the iterator is to model Forward Traversal
-Iterator or a more-refined iterator concept, a default constructor is
-required.
-
-
-
-Iterator Core Access
---------------------
-
-``iterator_facade`` and the operator implementations need to be able
-to access the core member functions in the derived class.  Making the
-core member functions public would expose an implementation detail to
-the user.  The design used here ensures that implementation details do
-not appear in the public interface of the derived iterator type.
-
-Preventing direct access to the core member functions has two
-advantages.  First, there is no possibility for the user to accidently
-use a member function of the iterator when a member of the value_type
-was intended.  This has been an issue with smart pointer
-implementations in the past.  The second and main advantage is that
-library implementers can freely exchange a hand-rolled iterator
-implementation for one based on ``iterator_facade`` without fear of
-breaking code that was accessing the public core member functions
-directly.
-
-In a naive implementation, keeping the derived class' core member
-functions private would require it to grant friendship to
-``iterator_facade`` and each of the seven operators.  In order to
-reduce the burden of limiting access, ``iterator_core_access`` is
-provided, a class that acts as a gateway to the core member functions
-in the derived iterator class.  The author of the derived class only
-needs to grant friendship to ``iterator_core_access`` to make his core
-member functions available to the library.
-
-.. This is no long uptodate -thw 
-.. Yes it is; I made sure of it! -DWA
-
-``iterator_core_access`` will be typically implemented as an empty
-class containing only private static member functions which invoke the
-iterator core member functions. There is, however, no need to
-standardize the gateway protocol.  Note that even if
-``iterator_core_access`` used public member functions it would not
-open a safety loophole, as every core member function preserves the
-invariants of the iterator.
-
-``operator[]``
---------------
-
-The indexing operator for a generalized iterator presents special
-challenges.  A random access iterator's ``operator[]`` is only
-required to return something convertible to its ``value_type``.
-Requiring that it return an lvalue would rule out currently-legal
-random-access iterators which hold the referenced value in a data
-member (e.g. |counting|_), because ``*(p+n)`` is a reference
-into the temporary iterator ``p+n``, which is destroyed when
-``operator[]`` returns.
-
-.. |counting| replace:: ``counting_iterator``
-
-Writable iterators built with ``iterator_facade`` implement the
-semantics required by the preferred resolution to `issue 299`_ and
-adopted by proposal n1550_: the result of ``p[n]`` is an object
-convertible to the iterator's ``value_type``, and ``p[n] = x`` is
-equivalent to ``*(p + n) = x`` (Note: This result object may be
-implemented as a proxy containing a copy of ``p+n``).  This approach
-will work properly for any random-access iterator regardless of the
-other details of its implementation.  A user who knows more about
-the implementation of her iterator is free to implement an
-``operator[]`` that returns an lvalue in the derived iterator
-class; it will hide the one supplied by ``iterator_facade`` from
-clients of her iterator.
-
-.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html
-
-.. _`issue 299`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299
-
-.. _`operator arrow`:
-
-
-``operator->``
---------------
-
-The ``reference`` type of a readable iterator (and today's input
-iterator) need not in fact be a reference, so long as it is
-convertible to the iterator's ``value_type``.  When the ``value_type``
-is a class, however, it must still be possible to access members
-through ``operator->``.  Therefore, an iterator whose ``reference``
-type is not in fact a reference must return a proxy containing a copy
-of the referenced value from its ``operator->``.
-
-The return types for ``iterator_facade``\ 's ``operator->`` and
-``operator[]`` are not explicitly specified. Instead, those types
-are described in terms of a set of requirements, which must be
-satisfied by the ``iterator_facade`` implementation.
-
-.. [Cop95] [Coplien, 1995] Coplien, J., Curiously Recurring Template
-   Patterns, C++ Report, February 1995, pp. 24-27.
-

doc/iterator_facade_ref.rst

@@ -1,438 +0,0 @@
-.. 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
-
-
-.. parsed-literal::
-
-  template <
-      class Derived
-    , class Value
-    , class CategoryOrTraversal
-    , class Reference  = Value&
-    , class Difference = ptrdiff_t
-  >
-  class iterator_facade {
-   public:
-      typedef remove_const<Value>::type value_type;
-      typedef Reference reference;
-      typedef Value\* pointer;
-      typedef Difference difference_type;
-      typedef /* see below__ \*/ iterator_category;
-
-      reference operator\*() const;
-      /* see below__ \*/ operator->() const;
-      /* see below__ \*/ operator[](difference_type n) const;
-      Derived& operator++();
-      Derived operator++(int);
-      Derived& operator--();
-      Derived operator--(int);
-      Derived& operator+=(difference_type n);
-      Derived& operator-=(difference_type n);
-      Derived operator-(difference_type n) const;
-   protected:
-      typedef iterator_facade iterator_facade\_;
-  };
-
-  // Comparison operators
-  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,bool>::type // exposition
-  operator ==(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
-              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
-
-  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,bool>::type
-  operator !=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
-              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
-
-  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,bool>::type
-  operator <(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
-             iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
-
-  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,bool>::type
-  operator <=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
-              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
-
-  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,bool>::type
-  operator >(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
-             iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
-
-  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,bool>::type
-  operator >=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
-              iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
-
-  // Iterator difference
-  template <class Dr1, class V1, class TC1, class R1, class D1,
-            class Dr2, class V2, class TC2, class R2, class D2>
-  /* see below__ \*/
-  operator-(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
-            iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
-
-  // Iterator addition
-  template <class Dr, class V, class TC, class R, class D>
-  Derived operator+ (iterator_facade<Dr,V,TC,R,D> const&,
-                     typename Derived::difference_type n);
-
-  template <class Dr, class V, class TC, class R, class D>
-  Derived operator+ (typename Derived::difference_type n,
-                     iterator_facade<Dr,V,TC,R,D> const&);
-
-__ `iterator category`_
-
-__ `operator arrow`_
-
-__ brackets_
-
-__ minus_
-
-.. _`iterator category`:
-
-The ``iterator_category`` member of ``iterator_facade`` is
-
-.. parsed-literal::
-
-  *iterator-category*\ (CategoryOrTraversal, value_type, reference)
-
-where *iterator-category* is defined as follows:
-
-.. include:: facade_iterator_category.rst
-
-The ``enable_if_interoperable`` template used above is for exposition
-purposes.  The member operators should only be in an overload set
-provided the derived types ``Dr1`` and ``Dr2`` are interoperable, 
-meaning that at least one of the types is convertible to the other.  The
-``enable_if_interoperable`` approach uses SFINAE to take the operators
-out of the overload set when the types are not interoperable.  
-The operators should behave *as-if* ``enable_if_interoperable``
-were defined to be::
-
-  template <bool, typename> enable_if_interoperable_impl
-  {};
-
-  template <typename T> enable_if_interoperable_impl<true,T>
-  { typedef T type; };
-
-  template<typename Dr1, typename Dr2, typename T>
-  struct enable_if_interoperable
-    : enable_if_interoperable_impl<
-          is_convertible<Dr1,Dr2>::value || is_convertible<Dr2,Dr1>::value
-        , T
-      >
-  {};
-
-
-``iterator_facade`` Requirements
---------------------------------
-
-The following table describes the typical valid expressions on
-``iterator_facade``\ 's ``Derived`` parameter, depending on the
-iterator concept(s) it will model.  The operations in the first
-column must be made accessible to member functions of class
-``iterator_core_access``.  In addition,
-``static_cast<Derived*>(iterator_facade*)`` shall be well-formed.
-
-In the table below, ``F`` is ``iterator_facade<X,V,C,R,D>``, ``a`` is an
-object of type ``X``, ``b`` and ``c`` are objects of type ``const X``,
-``n`` is an object of ``F::difference_type``, ``y`` is a constant
-object of a single pass iterator type interoperable with ``X``, and ``z``
-is a constant object of a random access traversal iterator type
-interoperable with ``X``.
-
-.. _`core operations`:
-
-.. topic:: ``iterator_facade`` Core Operations
-
-   +--------------------+----------------------+-------------------------+---------------------------+
-   |Expression          |Return Type           |Assertion/Note           |Used to implement Iterator |
-   |                    |                      |                         |Concept(s)                 |
-   +====================+======================+=========================+===========================+
-   |``c.dereference()`` |``F::reference``      |                         |Readable Iterator, Writable|
-   |                    |                      |                         |Iterator                   |
-   +--------------------+----------------------+-------------------------+---------------------------+
-   |``c.equal(y)``      |convertible to bool   |true iff ``c`` and ``y`` |Single Pass Iterator       |
-   |                    |                      |refer to the same        |                           |
-   |                    |                      |position.                |                           |
-   +--------------------+----------------------+-------------------------+---------------------------+
-   |``a.increment()``   |unused                |                         |Incrementable Iterator     |
-   +--------------------+----------------------+-------------------------+---------------------------+
-   |``a.decrement()``   |unused                |                         |Bidirectional Traversal    |
-   |                    |                      |                         |Iterator                   |
-   +--------------------+----------------------+-------------------------+---------------------------+
-   |``a.advance(n)``    |unused                |                         |Random Access Traversal    |
-   |                    |                      |                         |Iterator                   |
-   +--------------------+----------------------+-------------------------+---------------------------+
-   |``c.distance_to(z)``|convertible to        |equivalent to            |Random Access Traversal    |
-   |                    |``F::difference_type``|``distance(c, X(z))``.   |Iterator                   |
-   +--------------------+----------------------+-------------------------+---------------------------+
-
-
-
-``iterator_facade`` operations
-------------------------------
-
-The operations in this section are described in terms of operations on
-the core interface of ``Derived`` which may be inaccessible
-(i.e. private).  The implementation should access these operations
-through member functions of class ``iterator_core_access``.
-
-``reference operator*() const;``
-
-:Returns: ``static_cast<Derived const*>(this)->dereference()``
-
-``operator->() const;`` (see below__)
-
-__ `operator arrow`_
-
-:Returns: If ``reference`` is a reference type, an object
-  of type ``pointer`` equal to::
-
-    &static_cast<Derived const*>(this)->dereference()
-
-  Otherwise returns an object of unspecified type such that, 
-  ``(*static_cast<Derived const*>(this))->m`` is equivalent to ``(w = **static_cast<Derived const*>(this),
-  w.m)`` for some temporary object ``w`` of type ``value_type``.
-
-.. _brackets:
-
-*unspecified* ``operator[](difference_type n) const;``
-
-:Returns: an object convertible to ``value_type``. For constant
-     objects ``v`` of type ``value_type``, and ``n`` of type
-     ``difference_type``, ``(*this)[n] = v`` is equivalent to
-     ``*(*this + n) = v``, and ``static_cast<value_type
-     const&>((*this)[n])`` is equivalent to
-     ``static_cast<value_type const&>(*(*this + n))``
-
-
-
-``Derived& operator++();``
-
-:Effects: 
-
-  ::
-
-    static_cast<Derived*>(this)->increment();
-    return *static_cast<Derived*>(this);
-
-``Derived operator++(int);``
-
-:Effects:
-
-  ::
-
-    Derived tmp(static_cast<Derived const*>(this));
-    ++*this;
-    return tmp;
-
-
-``Derived& operator--();``
-
-:Effects:
-
-   ::
-
-      static_cast<Derived*>(this)->decrement();
-      return *static_cast<Derived*>(this);
-
-
-``Derived operator--(int);``
-
-:Effects:
-
-  ::
-
-    Derived tmp(static_cast<Derived const*>(this));
-    --*this;
-    return tmp;
-
-
-``Derived& operator+=(difference_type n);``
-
-:Effects:
-
-  ::
-
-      static_cast<Derived*>(this)->advance(n);
-      return *static_cast<Derived*>(this);
-
-
-``Derived& operator-=(difference_type n);``
-
-:Effects:
- 
-  ::
-
-      static_cast<Derived*>(this)->advance(-n);
-      return *static_cast<Derived*>(this);
-
-
-``Derived operator-(difference_type n) const;``
-
-:Effects:
-
-  ::
-
-    Derived tmp(static_cast<Derived const*>(this));
-    return tmp -= n;
-
-::
-
-  template <class Dr, class V, class TC, class R, class D>
-  Derived operator+ (iterator_facade<Dr,V,TC,R,D> const&,
-                     typename Derived::difference_type n);
-
-  template <class Dr, class V, class TC, class R, class D>
-  Derived operator+ (typename Derived::difference_type n,
-                     iterator_facade<Dr,V,TC,R,D> const&);
-
-:Effects:
-
-  ::
-
-    Derived tmp(static_cast<Derived const*>(this));
-    return tmp += n;
-
-
-::
-
-  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,bool>::type
-  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 
-    ``((Dr1 const&)lhs).equal((Dr2 const&)rhs)``.
-
-  Otherwise, 
-    ``((Dr2 const&)rhs).equal((Dr1 const&)lhs)``.
-
-::
-
-  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,bool>::type
-  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 
-    ``!((Dr1 const&)lhs).equal((Dr2 const&)rhs)``.
-
-  Otherwise, 
-    ``!((Dr2 const&)rhs).equal((Dr1 const&)lhs)``.
-
-::
-
-  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,bool>::type
-  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 
-    ``((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) < 0``.
-
-  Otherwise, 
-    ``((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) > 0``.
-
-::
-
-  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,bool>::type
-  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 
-    ``((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) <= 0``.
-
-  Otherwise, 
-    ``((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) >= 0``.
-
-::
-
-  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,bool>::type
-  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 
-    ``((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) > 0``.
-
-  Otherwise, 
-    ``((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) < 0``.
-
-
-::
-
-  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,bool>::type
-  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 
-    ``((Dr1 const&)lhs).distance_to((Dr2 const&)rhs) >= 0``.
-
-  Otherwise, 
-    ``((Dr2 const&)rhs).distance_to((Dr1 const&)lhs) <= 0``.
-
-.. _minus:
-
-::
-
-  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
-  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`` 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

@@ -1,523 +0,0 @@
-.. 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)
-
-In this section we'll walk through the implementation of a few
-iterators using ``iterator_facade``, based around the simple
-example of a linked list of polymorphic objects.  This example was
-inspired by a `posting`__ by Keith Macdonald on the `Boost-Users`_
-mailing list.
-
-.. _`Boost-Users`: ../../../more/mailing_lists.htm#users
-
-__ http://thread.gmane.org/gmane.comp.lib.boost.user/5100
-
-The Problem
------------
-
-Say we've written a polymorphic linked list node base class::
-
-  # include <iostream>
-
-  struct node_base
-  {
-      node_base() : m_next(0) {}
-
-      // Each node manages all of its tail nodes
-      virtual ~node_base() { delete m_next; }
-
-      // Access the rest of the list
-      node_base* next() const { return m_next; }
-
-      // print to the stream
-      virtual void print(std::ostream& s) const = 0;
-      
-      // double the value
-      virtual void double_me() = 0;
-
-      void append(node_base* p)
-      {
-          if (m_next) 
-              m_next->append(p); 
-          else
-              m_next = p; 
-      }
-
-   private:
-      node_base* m_next;
-  };
-
-Lists can hold objects of different types by linking together
-specializations of the following template::
-
-  template <class T>
-  struct node : node_base
-  {
-      node(T x)
-        : m_value(x)
-      {}
-
-      void print(std::ostream& s) const { s << this->m_value; }
-      void double_me() { m_value += m_value; }
-
-   private:
-      T m_value;
-  };
-
-And we can print any node using the following streaming operator::
-
-  inline std::ostream& operator<<(std::ostream& s, node_base const& n)
-  {
-      n.print(s);
-      return s;
-  }
-
-Our first challenge is to build an appropriate iterator over these
-lists.
-
-A Basic Iterator Using ``iterator_facade``
-------------------------------------------
-
-We will construct a ``node_iterator`` class using inheritance from
-``iterator_facade`` to implement most of the iterator's operations.
-
-::
-
-  # include "node.hpp"
-  # include <boost/iterator/iterator_facade.hpp>
-
-  class node_iterator
-    : public boost::iterator_facade<...>
-  {
-     ...
-  };
-
-
-
-Template Arguments for ``iterator_facade``
-..........................................
-
-``iterator_facade`` has several template parameters, so we must decide
-what types to use for the arguments. The parameters are ``Derived``,
-``Value``, ``CategoryOrTraversal``, ``Reference``, and ``Difference``.
-
-
-``Derived``
-'''''''''''
-
-Because ``iterator_facade`` is meant to be used with the CRTP
-[Cop95]_ the first parameter is the iterator class name itself,
-``node_iterator``.
-
-``Value``
-'''''''''
-
-The ``Value`` parameter determines the ``node_iterator``\ 's
-``value_type``.  In this case, we are iterating over ``node_base``
-objects, so ``Value`` will be ``node_base``.
-
-
-``CategoryOrTraversal``
-'''''''''''''''''''''''
-
-Now we have to determine which `iterator traversal concept`_ our
-``node_iterator`` is going to model.  Singly-linked lists only have
-forward links, so our iterator can't can't be a `bidirectional
-traversal iterator`_.  Our iterator should be able to make multiple
-passes over the same linked list (unlike, say, an
-``istream_iterator`` which consumes the stream it traverses), so it
-must be a `forward traversal iterator`_.  Therefore, we'll pass
-``boost::forward_traversal_tag`` in this position [#category]_.
-
-.. [#category] ``iterator_facade`` also supports old-style category
-   tags, so we could have passed ``std::forward_iterator_tag`` here;
-   either way, the resulting iterator's ``iterator_category`` will
-   end up being ``std::forward_iterator_tag``.
-
-``Reference``
-'''''''''''''
-
-The ``Reference`` argument becomes the type returned by
-``node_iterator``\ 's dereference operation, and will also be the
-same as ``std::iterator_traits<node_iterator>::reference``.  The
-library's default for this parameter is ``Value&``; since
-``node_base&`` is a good choice for the iterator's ``reference``
-type, we can omit this argument, or pass ``use_default``.
-
-``Difference``
-''''''''''''''
-
-The ``Difference`` argument determines how the distance between
-two ``node_iterator``\ s will be measured and will also be the
-same as ``std::iterator_traits<node_iterator>::difference_type``.
-The library's default for ``Difference`` is ``std::ptrdiff_t``, an
-appropriate type for measuring the distance between any two
-addresses in memory, and one that works for almost any iterator,
-so we can omit this argument, too.
-
-The declaration of ``node_iterator`` will therefore look something
-like::
-
-  # include "node.hpp"
-  # include <boost/iterator/iterator_facade.hpp>
-
-  class node_iterator
-    : public boost::iterator_facade<
-          node_iterator
-        , node_base
-        , boost::forward_traversal_tag
-      >
-  {
-     ...
-  };
-
-Constructors and Data Members
-.............................
-
-Next we need to decide how to represent the iterator's position.
-This representation will take the form of data members, so we'll
-also need to write constructors to initialize them.  The
-``node_iterator``\ 's position is quite naturally represented using
-a pointer to a ``node_base``.  We'll need a constructor to build an
-iterator from a ``node_base*``, and a default constructor to
-satisfy the `forward traversal iterator`_ requirements [#default]_.
-Our ``node_iterator`` then becomes::
-
-  # include "node.hpp"
-  # include <boost/iterator/iterator_facade.hpp>
-
-  class node_iterator
-    : public boost::iterator_facade<
-          node_iterator
-        , node_base
-        , boost::forward_traversal_tag
-      >
-  {
-   public:
-      node_iterator()
-        : m_node(0)
-      {}
-
-      explicit node_iterator(node_base* p)
-        : m_node(p)
-      {}
-
-   private:
-      ...
-      node_base* m_node;
-  };
-
-.. [#default] Technically, the C++ standard places almost no
-   requirements on a default-constructed iterator, so if we were
-   really concerned with efficiency, we could've written the
-   default constructor to leave ``m_node`` uninitialized.
-
-Implementing the Core Operations
-................................
-
-The last step is to implement the `core operations`_ required by
-the concepts we want our iterator to model.  Referring to the
-table__, we can see that the first three rows are applicable
-because ``node_iterator`` needs to satisfy the requirements for
-`readable iterator`_, `single pass iterator`_, and `incrementable
-iterator`_.  
-
-__ `core operations`_
-
-We therefore need to supply ``dereference``,
-``equal``, and ``increment`` members.  We don't want these members
-to become part of ``node_iterator``\ 's public interface, so we can
-make them private and grant friendship to
-``boost::iterator_core_access``, a "back-door" that
-``iterator_facade`` uses to get access to the core operations::
-
-  # include "node.hpp"
-  # include <boost/iterator/iterator_facade.hpp>
-
-  class node_iterator
-    : public boost::iterator_facade<
-          node_iterator
-        , node_base
-        , boost::forward_traversal_tag
-      >
-  {
-   public:
-      node_iterator()
-        : m_node(0) {}
-
-      explicit node_iterator(node_base* p)
-        : m_node(p) {}
-
-   private:
-      friend class boost::iterator_core_access;
-
-      void increment() { m_node = m_node->next(); }
-
-      bool equal(node_iterator const& other) const
-      {
-          return this->m_node == other.m_node;
-      }
-
-      node_base& dereference() const { return *m_node; }
-
-      node_base* m_node;
-  };
-
-Voil<EFBFBD>; a complete and conforming readable, forward-traversal
-iterator!  For a working example of its use, see `this program`__.
-
-__ ../example/node_iterator1.cpp
-
-A constant ``node_iterator``
-----------------------------
-
-.. Sidebar:: Constant and Mutable iterators
-
-   The term **mutable iterator** means an iterator through which
-   the object it references (its "referent") can be modified.  A
-   **constant iterator** is one which doesn't allow modification of
-   its referent.  
-
-   The words *constant* and *mutable* don't refer to the ability to
-   modify the iterator itself.  For example, an ``int const*`` is a
-   non-\ ``const`` *constant iterator*, which can be incremented
-   but doesn't allow modification of its referent, and ``int*
-   const`` is a ``const`` *mutable iterator*, which cannot be
-   modified but which allows modification of its referent.
-
-   Confusing?  We agree, but those are the standard terms.  It
-   probably doesn't help much that a container's constant iterator
-   is called ``const_iterator``.
-
-Now, our ``node_iterator`` gives clients access to both ``node``\
-'s ``print(std::ostream&) const`` member function, but also its
-mutating ``double_me()`` member.  If we wanted to build a
-*constant* ``node_iterator``, we'd only have to make three
-changes:
-
-.. parsed-literal::
-
-  class const_node_iterator
-    : public boost::iterator_facade<
-          node_iterator
-        , node_base **const**
-        , boost::forward_traversal_tag
-      >
-  {
-   public:
-      const_node_iterator()
-        : m_node(0) {}
-
-      explicit const_node_iterator(node_base* p)
-        : m_node(p) {}
-
-   private:
-      friend class boost::iterator_core_access;
-
-      void increment() { m_node = m_node->next(); }
-
-      bool equal(const_node_iterator const& other) const
-      {
-          return this->m_node == other.m_node;
-      }
-
-      node_base **const**\ & dereference() const { return \*m_node; }
-
-      node_base **const**\ * m_node;
-  };
-
-.. Sidebar:: ``const`` and an iterator's ``value_type``
-
-   The C++ standard requires an iterator's ``value_type`` *not* be
-   ``const``\ -qualified, so ``iterator_facade`` strips the
-   ``const`` from its ``Value`` parameter in order to produce the
-   iterator's ``value_type``.  Making the ``Value`` argument
-   ``const`` provides a useful hint to ``iterator_facade`` that the
-   iterator is a *constant iterator*, and the default ``Reference``
-   argument will be correct for all lvalue iterators.
-
-As a matter of fact, ``node_iterator`` and ``const_node_iterator``
-are so similar that it makes sense to factor the common code out
-into a template as follows::
-
-  template <class Value>
-  class node_iter
-    : public boost::iterator_facade<
-          node_iter<Value>
-        , Value
-        , boost::forward_traversal_tag
-      >
-  {
-   public:
-      node_iter()
-        : m_node(0) {}
-
-      explicit node_iter(Value* p)
-        : m_node(p) {}
-
-   private:
-      friend class boost::iterator_core_access;
-
-      bool equal(node_iter<Value> const& other) const
-      {
-          return this->m_node == other.m_node;
-      }
-
-      void increment()
-      { m_node = m_node->next(); }
-
-      Value& dereference() const
-      { return *m_node; }
-
-      Value* m_node;
-  };
-  typedef node_iter<node_base> node_iterator;
-  typedef node_iter<node_base const> node_const_iterator;
-
-
-Interoperability
-----------------
-
-Our ``const_node_iterator`` works perfectly well on its own, but
-taken together with ``node_iterator`` it doesn't quite meet
-expectations.  For example, we'd like to be able to pass a
-``node_iterator`` where a ``node_const_iterator`` was expected,
-just as you can with ``std::list<int>``\ 's ``iterator`` and
-``const_iterator``.  Furthermore, given a ``node_iterator`` and a
-``node_const_iterator`` into the same list, we should be able to
-compare them for equality.
-
-This expected ability to use two different iterator types together
-is known as |interoperability|_.  Achieving interoperability in
-our case is as simple as templatizing the ``equal`` function and
-adding a templatized converting constructor [#broken]_ [#random]_::
-
-  template <class Value>
-  class node_iter
-    : public boost::iterator_facade<
-          node_iter<Value>
-        , Value
-        , boost::forward_traversal_tag
-      >
-  {
-   public:
-      node_iter()
-        : m_node(0) {}
-
-      explicit node_iter(Value* p)
-        : m_node(p) {}
-
-      template <class OtherValue>
-      node_iter(node_iter<OtherValue> const& other)
-        : m_node(other.m_node) {}
-
-   private:
-      friend class boost::iterator_core_access;
-      template <class> friend class node_iter;
-
-      template <class OtherValue>
-      bool equal(node_iter<OtherValue> const& other) const
-      { 
-          return this->m_node == other.m_node;
-      }
-
-      void increment()
-      { m_node = m_node->next(); }
-
-      Value& dereference() const
-      { return *m_node; }
-
-      Value* m_node;
-  };
-  typedef impl::node_iterator<node_base> node_iterator;
-  typedef impl::node_iterator<node_base const> node_const_iterator;
-
-.. |interoperability| replace:: **interoperability**
-.. _interoperability: new-iter-concepts.html#interoperable-iterators-lib-interoperable-iterators
-
-.. [#broken] If you're using an older compiler and it can't handle
-   this example, see the `example code`__ for workarounds.
-
-.. [#random] If ``node_iterator`` had been a `random access
-   traversal iterator`_, we'd have had to templatize its
-   ``distance_to`` function as well.
-
-
-__ ../example/node_iterator2.hpp
-
-You can see an example program which exercises our interoperable
-iterators `here`__.
-
-__ ../example/node_iterator2.cpp
-
-Telling the Truth
------------------
-
-Now ``node_iterator`` and ``node_const_iterator`` behave exactly as
-you'd expect... almost.  We can compare them and we can convert in
-one direction: from ``node_iterator`` to ``node_const_iterator``.
-If we try to convert from ``node_const_iterator`` to
-``node_iterator``, we'll get an error when the converting
-constructor tries to initialize ``node_iterator``\ 's ``m_node``, a
-``node*`` with a ``node const*``.  So what's the problem?
-
-The problem is that
-``boost::``\ |is_convertible|_\ ``<node_const_iterator,node_iterator>::value``
-will be ``true``, but it should be ``false``.  |is_convertible|_
-lies because it can only see as far as the *declaration* of
-``node_iter``\ 's converting constructor, but can't look inside at
-the *definition* to make sure it will compile.  A perfect solution
-would make ``node_iter``\ 's converting constructor disappear when
-the ``m_node`` conversion would fail.
-
-.. |is_convertible| replace:: ``is_convertible``
-.. _is_convertible:  ../../type_traits/index.html#relationships
-
-In fact, that sort of magic is possible using
-|enable_if|__.  By rewriting the converting constructor as
-follows, we can remove it from the overload set when it's not
-appropriate::
-
-  #include <boost/type_traits/is_convertible.hpp>
-  #include <boost/utility/enable_if.hpp>
-
-    ...
-
-  private: 
-    struct enabler {};
-
-  public:
-    template <class OtherValue>
-    node_iter(
-        node_iter<OtherValue> const& other
-      , typename boost::enable_if<
-            boost::is_convertible<OtherValue*,Value*>
-          , enabler
-        >::type = enabler()
-    )
-      : m_node(other.m_node) {}
-
-.. |enable_if| replace:: ``boost::enable_if``
-__ ../../utility/enable_if.html
-
-
-Wrap Up
--------
-
-This concludes our ``iterator_facade`` tutorial, but before you
-stop reading we urge you to take a look at |iterator_adaptor|__.
-There's another way to approach writing these iterators which might
-even be superior.
-
-.. |iterator_adaptor| replace:: ``iterator_adaptor``
-__ iterator_adaptor.html
-
-.. _`iterator traversal concept`: new-iter-concepts.html#iterator-traversal-concepts-lib-iterator-traversal
-.. _`readable iterator`: new-iter-concepts.html#readable-iterators-lib-readable-iterators
-.. _`lvalue iterator`: new-iter-concepts.html#lvalue-iterators-lib-lvalue-iterators
-.. _`single pass iterator`: new-iter-concepts.html#single-pass-iterators-lib-single-pass-iterators
-.. _`incrementable iterator`: new-iter-concepts.html#incrementable-iterators-lib-incrementable-iterators
-.. _`forward traversal iterator`: new-iter-concepts.html#forward-traversal-iterators-lib-forward-traversal-iterators
-.. _`bidirectional traversal iterator`: new-iter-concepts.html#bidirectional-traversal-iterators-lib-bidirectional-traversal-iterators
-.. _`random access traversal iterator`: new-iter-concepts.html#random-access-traversal-iterators-lib-random-access-traversal-iterators
-

doc/iterator_traits.html

@@ -1,120 +0,0 @@
-<?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.1: 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-01-13" />
-<meta name="copyright" content="Copyright David Abrahams 2004. All rights reserved" />
-<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-01-13</td></tr>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams 2004. All rights reserved</td></tr>
-</tbody>
-</table>
-<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">abstract:</th><td class="field-body">Header <tt class="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/index.html#metafunctions">metafunctions</a>.</td>
-</tr>
-</tbody>
-</table>
-<div class="section" id="overview">
-<h1><a name="overview">Overview</a></h1>
-<p><tt class="literal"><span class="pre">std::iterator_traits</span></tt> provides access to five associated types
-of any iterator: its <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>,
-<tt class="literal"><span class="pre">iterator_category</span></tt>, and <tt class="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="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/index.html#metafunctions">metafunctions</a>.</p>
-</div>
-<div class="section" id="summary">
-<h1><a name="summary">Summary</a></h1>
-<p>Header <tt class="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/index.html#metafunctions">metafunctions</a> actually work better than the facilities provided by
-your compiler's standard library.</p>
-<p>On compilers that don't support partial specialization, such as
-Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke
-<a class="reference" href="../../type_traits/index.html#transformations">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</a> on the
-<tt class="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="literal"><span class="pre">iterator_category</span></tt> is changed to <tt class="literal"><span class="pre">iterator_category_</span></tt> on that
-compiler.  A macro, <tt class="literal"><span class="pre">BOOST_ITERATOR_CATEGORY</span></tt>, that expands to
-either <tt class="literal"><span class="pre">iterator_category</span></tt> or <tt class="literal"><span class="pre">iterator_category_</span></tt>, as
-appropriate to the platform, is provided for portability.</p>
-</div>
-</div>
-<hr class="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

@@ -1,94 +0,0 @@
-+++++++++++++++++
- Iterator Traits
-+++++++++++++++++
-
-:Author: David Abrahams
-:Contact: dave@boost-consulting.com
-:organization: `Boost Consulting`_
-:date: $Date$
-:copyright: Copyright David Abrahams 2004. All rights reserved
-
-.. _`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_counting_iterator.rst

@@ -1,9 +0,0 @@
-
-::
-
-    template <class Incrementable>
-    counting_iterator<Incrementable> make_counting_iterator(Incrementable x);
-
-:Returns: An instance of ``counting_iterator<Incrementable>``
-    with ``current`` constructed from ``x``.
-

doc/make_filter_iterator.html

@@ -1,53 +0,0 @@
-<?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.2.8: http://docutils.sourceforge.net/" />
-<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">An instance of <tt class="literal"><span class="pre">filter_iterator&lt;Predicate,Iterator&gt;</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(*this-&gt;base())</span> <span class="pre">==</span> <span class="pre">true</span></tt> or else <tt class="literal"><span class="pre">m_iter</span> <span class="pre">==</span> <span class="pre">end</span></tt>.
-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>
-<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">An instance of <tt class="literal"><span class="pre">filter_iterator&lt;Predicate,Iterator&gt;</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(*this-&gt;base())</span> <span class="pre">==</span> <span class="pre">true</span></tt>, where <tt class="literal"><span class="pre">f</span></tt> is a default
-constructed <tt class="literal"><span class="pre">Predicate</span></tt>, or else <tt class="literal"><span class="pre">m_iter</span> <span class="pre">==</span> <span class="pre">end</span></tt>.
-The member <tt class="literal"><span class="pre">m_pred</span></tt> is default constructed and  <tt class="literal"><span class="pre">m_end</span></tt> 
-is constructed from <tt class="literal"><span class="pre">end</span></tt>.</td>
-</tr>
-</tbody>
-</table>
-</div>
-<hr class="footer"/>
-<div class="footer">
-<a class="reference" href="make_filter_iterator.rst">View document source</a>.
-Generated on: 2004-01-13 02:57 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>
-</html>