This commit was manufactured by cvs2svn to create branch

'thread_rewrite'.

[SVN r30953]

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/GNUmakefile

@@ -1,232 +0,0 @@
-# GNUmakefile for postprocessing PDF files
-#
-# © 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
-CAT	= /bin/cat
-TOUCH 	= /bin/touch
-ZIP	= /usr/bin/zip
-
-# ... TeX & postprocessors
-PPOWER4	      = ppower4
-PDFLATEX      = pdflatex
-METAPOST      = mpost
-FIG2DEV	      = fig2dev
-BIBTEX	      = bibtex
-FOLIAGECUTTER = foliageCutter --verbose
-RST2LATEX	  = rst2latex --documentclass book --documentoptions 10pt,twoside,pdftex # --use-latex-toc
-RST2HTML	  = rst2html
-
-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
-DEPENDFILE = .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 .depend *.ps TMP-*.pdf *.ftoc\
-	    ${PRINTZIP} ${SLIDEZIP} ${GENFILE} ${DEPENDFILE} \
-	    ${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 .depend ${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
-	@for t in ${RSTSTEMS} ; do \
-		${ECHO} "Scanning $$t.rst"; \
-		${PERL} -e 'my $$target = shift @ARGV;' -e 'while (<>) { /^\.\. include::\s+(.*)/ && print "$$target: $$1\n";}' $$t.html < $$t.rst >> $@; \
-		${PERL} -e 'my $$target = shift @ARGV;' -e 'while (<>) { /^\.\. include::\s+(.*)/ && print "$$target: $$1\n";}' $$t.tex < $$t.rst >> $@; \
-	done
-
-
-# ... include dependency file
--include .depend

doc/counting_iterator.html

@@ -1,347 +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="2003-09-14" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
-<style type="text/css"><!--
-
-/*
-: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 {
-  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 {
-  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.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.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-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-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 }
-
---></style>
-</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>2003-09-14</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"></td>
-</tr>
-</tbody>
-</table>
-<p>The counting iterator adaptor implements dereference by returning a
-reference to the base object. The other operations are implemented by
-the base <tt class="literal"><span class="pre">m_iterator</span></tt>, as per the inheritance from
-<tt class="literal"><span class="pre">iterator_adaptor</span></tt>.</p>
-<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-requirements" id="id1" name="id1"><tt class="literal"><span class="pre">counting_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#counting-iterator-operations" id="id2" name="id2"><tt class="literal"><span class="pre">counting_iterator</span></tt> operations</a></li>
-</ul>
-</div>
-<pre class="literal-block">
-template &lt;
-    class Incrementable
-  , unsigned Access = use_default_access
-  , class Traversal = use_default
-  , class Difference = use_default
-&gt;
-class counting_iterator
-  : public iterator_adaptor&lt;
-        counting_iterator&lt;Incrementable, Access, Traversal, Difference&gt;
-      , Incrementable
-      , Incrementable
-      , Access
-      , /* see details for traversal category */
-      , Incrementable const&amp;
-      , Incrementable const*
-      , /* distance = Difference or a signed integral type */&gt;
-{
-    friend class iterator_core_access;
- public:
-    counting_iterator();
-    counting_iterator(counting_iterator const&amp; rhs);
-    counting_iterator(Incrementable x);
- private:
-    typename counting_iterator::reference dereference() const
-    {
-        return this-&gt;base_reference();
-    }
-  };
-</pre>
-<dl>
-<dt>[<em>Note:</em> implementers are encouraged to provide an implementation of</dt>
-<dd><tt class="literal"><span class="pre">distance_to</span></tt> and a <tt class="literal"><span class="pre">difference_type</span></tt> that avoids overflows in
-the cases when the <tt class="literal"><span class="pre">Incrementable</span></tt> type is a numeric type.]</dd>
-</dl>
-<div class="section" id="counting-iterator-requirements">
-<h1><a class="toc-backref" href="#id1" 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> type must be Default Constructible, Copy
-Constructible, and Assignable.  The default distance is
-an implementation defined signed integegral type.</p>
-<p>The resulting <tt class="literal"><span class="pre">counting_iterator</span></tt> models Readable Lvalue Iterator.</p>
-<p>Furthermore, if you wish to create a counting iterator that is a Forward
-Traversal Iterator, then the following expressions must be valid:</p>
-<pre class="literal-block">
-Incrementable i, j;
-++i         // pre-increment
-i == j      // operator equal
-</pre>
-<p>If you wish to create a counting iterator that is a 
-Bidirectional Traversal Iterator, then pre-decrement is also required:</p>
-<pre class="literal-block">
---i
-</pre>
-<p>If you wish to create a counting iterator that is a Random Access
-Traversal Iterator, then these additional expressions are also
-required:</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-operations">
-<h1><a class="toc-backref" href="#id2" name="counting-iterator-operations"><tt class="literal"><span class="pre">counting_iterator</span></tt> operations</a></h1>
-<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">Returns:</th><td class="field-body">A default constructed instance of <tt class="literal"><span class="pre">counting_iterator</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">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">counting_iterator</span></tt> that is a copy of <tt class="literal"><span class="pre">rhs</span></tt>.</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><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">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">counting_iterator</span></tt> with its base
-object copy constructed from <tt class="literal"><span class="pre">x</span></tt>.</td>
-</tr>
-</tbody>
-</table>
-</div>
-</div>
-<hr class="footer" />
-<div class="footer">
-<a class="reference" href="counting_iterator.rst">View document source</a>.
-Generated on: 2003-11-24 05:00 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/counting_iterator.rst

@@ -1,23 +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:
-
-.. include:: counting_iterator_abstract.rst
-
-.. contents:: Table of Contents
-
-.. include:: counting_iterator_ref.rst

doc/counting_iterator_abstract.rst

@@ -1,5 +0,0 @@
-The counting iterator adaptor implements dereference by returning a
-reference to the base object. The other operations are implemented by
-the base ``m_iterator``, as per the inheritance from
-``iterator_adaptor``.
-

doc/counting_iterator_ref.rst

@@ -1,91 +0,0 @@
-::
-
-  template <
-      class Incrementable
-    , unsigned Access = use_default_access
-    , class Traversal = use_default
-    , class Difference = use_default
-  >
-  class counting_iterator
-    : public iterator_adaptor<
-          counting_iterator<Incrementable, Access, Traversal, Difference>
-        , Incrementable
-        , Incrementable
-        , Access
-        , /* see details for traversal category */
-        , Incrementable const&
-        , Incrementable const*
-        , /* distance = Difference or a signed integral type */>
-  {
-      friend class iterator_core_access;
-   public:
-      counting_iterator();
-      counting_iterator(counting_iterator const& rhs);
-      counting_iterator(Incrementable x);
-   private:
-      typename counting_iterator::reference dereference() const
-      {
-          return this->base_reference();
-      }
-    };
-
-
-[*Note:* implementers are encouraged to provide an implementation of
-  ``distance_to`` and a ``difference_type`` that avoids overflows in
-  the cases when the ``Incrementable`` type is a numeric type.]
-
-``counting_iterator`` requirements
-----------------------------------
-
-The ``Incrementable`` type must be Default Constructible, Copy
-Constructible, and Assignable.  The default distance is
-an implementation defined signed integegral type.
-
-The resulting ``counting_iterator`` models Readable Lvalue Iterator.
-
-Furthermore, if you wish to create a counting iterator that is a Forward
-Traversal Iterator, then the following expressions must be valid:
-::
-
-    Incrementable i, j;
-    ++i         // pre-increment
-    i == j      // operator equal
-
-If you wish to create a counting iterator that is a 
-Bidirectional Traversal Iterator, then pre-decrement is also required:
-::
-
-    --i
-
-If you wish to create a counting iterator that is a Random Access
-Traversal Iterator, then these additional expressions are also
-required:
-::
-
-    counting_iterator::difference_type n;
-    i += n
-    n = i - j
-    i < j
-
-
-
-
-``counting_iterator`` operations
---------------------------------
-
-``counting_iterator();``
-
-:Returns: A default constructed instance of ``counting_iterator``.
-
-
-``counting_iterator(counting_iterator const& rhs);``
-
-:Returns: An instance of ``counting_iterator`` that is a copy of ``rhs``.
-
-
-
-``counting_iterator(Incrementable x);``
-
-:Returns: An instance of ``counting_iterator`` with its base
-    object copy constructed from ``x``.
-

doc/default.css

@@ -1,188 +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 {
-  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 {
-  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.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.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-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-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/facade-and-adaptor.rst

@@ -1,423 +0,0 @@
-+++++++++++++++++++++++++++++
- Iterator Facade and Adaptor
-+++++++++++++++++++++++++++++
-
-:Author: David Abrahams, Jeremy Siek, Thomas Witt
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@acm.org
-:organization: `Boost Consulting`_, Indiana University `Open Systems
-               Lab`_, University of Hanover `Institute for Transport
-               Railway Operation and Construction`_
-: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
-.. _`Institute for Transport Railway Operation and Construction`: http://www.ive.uni-hannover.de
-
-: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.
-
-* ``projection_iterator``, which is similar to ``transform_iterator``
-  except that when dereferenced it returns a reference instead of
-  a value.
-
-* ``filter_iterator``, which provides a view of an iterator range in
-  which some elements of the underlying range are skipped.
-
-.. _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 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 ``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/filter_iterator.html

@@ -1,388 +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="2003-09-14" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
-<style type="text/css"><!--
-
-/*
-: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 {
-  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 {
-  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.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.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-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-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 }
-
---></style>
-</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>2003-09-14</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"></td>
-</tr>
-</tbody>
-</table>
-<p>The filter iterator adaptor creates a view of an iterator range in
-which some elements of the range are skipped over. 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. Therefore the constructor of the filter
-iterator takes two iterator parameters: the position for the filtered
-iterator and the end of the range.</p>
-<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-requirements" id="id1" name="id1"><tt class="literal"><span class="pre">filter_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#filter-iterator-operations" id="id2" name="id2"><tt class="literal"><span class="pre">filter_iterator</span></tt> operations</a></li>
-</ul>
-</div>
-<pre class="literal-block">
-template &lt;class Predicate, class Iterator&gt;
-class filter_iterator
-    : public iterator_adaptor&lt;
-          filter_iterator&lt;Predicate, Iterator&gt;, Iterator
-        , use_default
-        , /* see details */
-      &gt;
-{
- public:
-    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;
-
- private: // as-if specification
-    void increment()
-    {
-        ++(this-&gt;base_reference());
-        satisfy_predicate();
-    }
-
-    void satisfy_predicate()
-    {
-        while (this-&gt;base() != this-&gt;m_end &amp;&amp; !this-&gt;m_predicate(*this-&gt;base()))
-            ++(this-&gt;base_reference());
-    }
-
-    Predicate m_predicate;
-    Iterator m_end;
-};
-</pre>
-<div class="section" id="filter-iterator-requirements">
-<h1><a class="toc-backref" href="#id1" name="filter-iterator-requirements"><tt class="literal"><span class="pre">filter_iterator</span></tt> requirements</a></h1>
-<p>The base <tt class="literal"><span class="pre">Iterator</span></tt> parameter must be a model of Readable
-Iterator and Single Pass Iterator. The resulting
-<tt class="literal"><span class="pre">filter_iterator</span></tt> will be a model of Forward Traversal Iterator
-if <tt class="literal"><span class="pre">Iterator</span></tt> is, otherwise the <tt class="literal"><span class="pre">filter_iterator</span></tt> will be a
-model of Single Pass Iterator. The access category of the
-<tt class="literal"><span class="pre">filter_iterator</span></tt> will be the same as the access category of
-<tt class="literal"><span class="pre">Iterator</span></tt>.</p>
-<!-- Thomas is going to try implementing filter_iterator so that
-it will be bidirectional if the underlying iterator is. -JGS -->
-<p>The <tt class="literal"><span class="pre">Predicate</span></tt> 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-operations">
-<h1><a class="toc-backref" href="#id2" name="filter-iterator-operations"><tt class="literal"><span class="pre">filter_iterator</span></tt> operations</a></h1>
-<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
-predicate is a default constructed <tt class="literal"><span class="pre">Predicate</span></tt> and
-whose <tt class="literal"><span class="pre">end</span></tt> is a default constructed <tt class="literal"><span class="pre">Iterator</span></tt>.</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> at position <tt class="literal"><span class="pre">x</span></tt> that filters according
-to predicate <tt class="literal"><span class="pre">f</span></tt> and that will not increment past <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> at position <tt class="literal"><span class="pre">x</span></tt> that filters 
-according to a default constructed <tt class="literal"><span class="pre">Predicate</span></tt>
-and that will not increment past <tt class="literal"><span class="pre">end</span></tt>.</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 copy of iterator <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">A copy of the predicate object used to construct <tt class="literal"><span class="pre">*this</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">The object <tt class="literal"><span class="pre">end</span></tt> used to construct <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.rst">View document source</a>.
-Generated on: 2003-11-24 05:00 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.rst

@@ -1,23 +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
-
-.. include:: filter_iterator_ref.rst

doc/filter_iterator_abstract.rst

@@ -1,10 +0,0 @@
-The filter iterator adaptor creates a view of an iterator range in
-which some elements of the range are skipped over. 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. Therefore the constructor of the filter
-iterator takes two iterator parameters: the position for the filtered
-iterator and the end of the range.

doc/filter_iterator_ref.rst

@@ -1,109 +0,0 @@
-::
-
-  template <class Predicate, class Iterator>
-  class filter_iterator
-      : public iterator_adaptor<
-            filter_iterator<Predicate, Iterator>, Iterator
-          , use_default
-          , /* see details */
-        >
-  {
-   public:
-      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;
-
-   private: // as-if specification
-      void increment()
-      {
-          ++(this->base_reference());
-          satisfy_predicate();
-      }
-
-      void satisfy_predicate()
-      {
-          while (this->base() != this->m_end && !this->m_predicate(*this->base()))
-              ++(this->base_reference());
-      }
-
-      Predicate m_predicate;
-      Iterator m_end;
-  };
-
-
-``filter_iterator`` requirements
---------------------------------
-
-The base ``Iterator`` parameter must be a model of Readable
-Iterator and Single Pass Iterator. The resulting
-``filter_iterator`` will be a model of Forward Traversal Iterator
-if ``Iterator`` is, otherwise the ``filter_iterator`` will be a
-model of Single Pass Iterator. The access category of the
-``filter_iterator`` will be the same as the access category of
-``Iterator``.
-
-.. Thomas is going to try implementing filter_iterator so that
-   it will be bidirectional if the underlying iterator is. -JGS
-
-
-The ``Predicate`` 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`` operations
-------------------------------
-
-``filter_iterator();``
-
-:Requires: ``Predicate`` and ``Iterator`` must be Default Constructible.
-:Returns: a ``filter_iterator`` whose
-    predicate is a default constructed ``Predicate`` and
-    whose ``end`` is a default constructed ``Iterator``.
-
-
-``filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());``
-
-:Returns: A ``filter_iterator`` at position ``x`` that filters according
-    to predicate ``f`` and that will not increment past ``end``.
-
-
-``filter_iterator(Iterator x, Iterator end = Iterator());``
-
-:Requires: ``Predicate`` must be Default Constructible.
-:Returns: A ``filter_iterator`` at position ``x`` that filters 
-    according to a default constructed ``Predicate``
-    and that will not increment past ``end``.
-
-
-::
-
-    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``.
-:Returns: A copy of iterator ``t``. 
-
-
-``Predicate predicate() const;``
-
-:Returns: A copy of the predicate object used to construct ``*this``.
-
-
-``Iterator end() const;``
-
-:Returns: The object ``end`` used to construct ``*this``.
-

doc/function_output_iterator.html

@@ -1,356 +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="2003-09-14" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
-<style type="text/css"><!--
-
-/*
-: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 {
-  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 {
-  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.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.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-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-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 }
-
---></style>
-</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>2003-09-14</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"></td>
-</tr>
-</tbody>
-</table>
-<p>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.</p>
-<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-operations" id="id2" name="id2"><tt class="literal"><span class="pre">function_output_iterator</span></tt> operations</a></li>
-<li><a class="reference" href="#function-output-iterator-output-proxy-operations" id="id3" name="id3"><tt class="literal"><span class="pre">function_output_iterator::output_proxy</span></tt> operations</a></li>
-</ul>
-</div>
-<pre class="literal-block">
-template &lt;class UnaryFunction&gt;
-class function_output_iterator {
-public:
-  typedef iterator_tag&lt;
-        writable_iterator
-      , incrementable_traversal_tag
-  &gt; iterator_category;
-  typedef void                value_type;
-  typedef void                difference_type;
-  typedef void                pointer;
-  typedef void                reference;
-
-  explicit function_output_iterator(const UnaryFunction&amp; f = UnaryFunction());
-
-  struct output_proxy {
-    output_proxy(UnaryFunction&amp; f);
-    template &lt;class T&gt; output_proxy&amp; operator=(const T&amp; value);
-  };
-  output_proxy operator*();
-  function_output_iterator&amp; operator++();
-  function_output_iterator&amp; operator++(int);
-};
-</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>The <tt class="literal"><span class="pre">UnaryFunction</span></tt> must be Assignable, Copy Constructible, and the
-expression <tt class="literal"><span class="pre">f(x)</span></tt> must be valid, where <tt class="literal"><span class="pre">f</span></tt> is an object of type
-<tt class="literal"><span class="pre">UnaryFunction</span></tt> and <tt class="literal"><span class="pre">x</span></tt> is an object of a type accepted by <tt class="literal"><span class="pre">f</span></tt>.
-The resulting <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="#id2" 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">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">function_output_iterator</span></tt> with
-<tt class="literal"><span class="pre">f</span></tt> stored as a data member.</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">output_proxy</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">An instance of <tt class="literal"><span class="pre">output_proxy</span></tt> constructed with
-a copy of the unary function <tt class="literal"><span class="pre">f</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="function-output-iterator-output-proxy-operations">
-<h1><a class="toc-backref" href="#id3" name="function-output-iterator-output-proxy-operations"><tt class="literal"><span class="pre">function_output_iterator::output_proxy</span></tt> operations</a></h1>
-<p><tt class="literal"><span class="pre">output_proxy(UnaryFunction&amp;</span> <span class="pre">f);</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">output_proxy</span></tt> with <tt class="literal"><span class="pre">f</span></tt> stored as
-a data member.</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">template</span> <span class="pre">&lt;class</span> <span class="pre">T&gt;</span> <span class="pre">output_proxy&amp;</span> <span class="pre">operator=(const</span> <span class="pre">T&amp;</span> <span class="pre">value);</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"><pre class="first last literal-block">
-m_f(value); 
-return *this; 
-</pre>
-</td>
-</tr>
-</tbody>
-</table>
-</div>
-</div>
-<hr class="footer" />
-<div class="footer">
-<a class="reference" href="function_output_iterator.rst">View document source</a>.
-Generated on: 2003-11-24 05:00 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/function_output_iterator.rst

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

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_ref.rst

@@ -1,77 +0,0 @@
-::
-
-  template <class UnaryFunction>
-  class function_output_iterator {
-  public:
-    typedef iterator_tag<
-          writable_iterator
-        , incrementable_traversal_tag
-    > iterator_category;
-    typedef void                value_type;
-    typedef void                difference_type;
-    typedef void                pointer;
-    typedef void                reference;
-
-    explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());
-
-    struct output_proxy {
-      output_proxy(UnaryFunction& f);
-      template <class T> output_proxy& operator=(const T& value);
-    };
-    output_proxy operator*();
-    function_output_iterator& operator++();
-    function_output_iterator& operator++(int);
-  };
-
-
-``function_output_iterator`` requirements
------------------------------------------
-
-The ``UnaryFunction`` must be Assignable, Copy Constructible, and the
-expression ``f(x)`` must be valid, where ``f`` is an object of type
-``UnaryFunction`` and ``x`` is an object of a type accepted by ``f``.
-The resulting ``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());``
-
-:Returns: An instance of ``function_output_iterator`` with
-  ``f`` stored as a data member.
-
-
-``output_proxy operator*();``
-
-:Returns: An instance of ``output_proxy`` constructed with
-  a copy of the unary function ``f``.
-  
-
-``function_output_iterator& operator++();``
-
-:Returns: ``*this``
-
-
-``function_output_iterator& operator++(int);``
-
-:Returns: ``*this``
-
-
-``function_output_iterator::output_proxy`` operations
------------------------------------------------------
-
-``output_proxy(UnaryFunction& f);``
-
-:Returns: An instance of ``output_proxy`` with ``f`` stored as
-    a data member.
-
-
-``template <class T> output_proxy& operator=(const T& value);``
-
-:Effects: 
-  ::
-
-      m_f(value); 
-      return *this; 

doc/generate.py

@@ -1,29 +0,0 @@
-#!/usr/bin/python
-
-#
-# 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', 'tex', '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,416 +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>The Boost.Iterator Library Boost</title>
-<style type="text/css"><!--
-
-/*
-: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 {
-  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 {
-  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.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.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-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-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 }
-
---></style>
-</head>
-<body>
-<div class="document" id="the-boost-iterator-library-logo">
-<h1 class="title">The Boost.Iterator Library <a class="reference" href="../../../index.htm"><img alt="Boost" src="../../../c++boost.gif" /></a></h1>
-<hr />
-<table class="field-list" frame="void" rules="none">
-<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;ive.uni-hannover.de">witt&#64;ive.uni-hannover.de</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>, University of Hanover <a class="reference" href="http://www.ive.uni-hannover.de">Institute for Transport
-Railway Operation and Construction</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 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"><a name="table-of-contents"><strong>Table of Contents</strong></a></p>
-<ul class="simple">
-<li><a class="reference" href="#new-style-iterators" id="id6" name="id6">New-Style Iterators</a></li>
-<li><a class="reference" href="#iterator-facade-and-adaptor" id="id7" name="id7">Iterator Facade and Adaptor</a></li>
-<li><a class="reference" href="#specialized-adaptors" id="id8" name="id8">Specialized Adaptors</a></li>
-<li><a class="reference" href="#iterator-utilities" id="id9" name="id9">Iterator Utilities</a><ul>
-<li><a class="reference" href="#traits" id="id10" name="id10">Traits</a></li>
-<li><a class="reference" href="#testing-and-concept-checking" id="id11" name="id11">Testing and Concept Checking</a></li>
-</ul>
-</li>
-<li><a class="reference" href="#upgrading-from-the-old-boost-iterator-adaptor-library" id="id12" name="id12">Upgrading from the old Boost Iterator Adaptor Library</a></li>
-<li><a class="reference" href="#history" id="id13" name="id13">History</a></li>
-</ul>
-</div>
-<hr />
-<div class="section" id="new-style-iterators">
-<h1><a class="toc-backref" href="#id6" 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></blockquote>
-</div>
-<div class="section" id="iterator-facade-and-adaptor">
-<h1><a class="toc-backref" href="#id7" name="iterator-facade-and-adaptor">Iterator Facade and Adaptor</a></h1>
-<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 <a class="reference" href="iterator_facade.html"><tt class="literal"><span class="pre">iterator_facade</span></tt></a> class template,
-which implements many useful defaults and compile-time checks
-designed to help the author iterator ensure that his iterator is
-correct.  It is common to define a new iterator which behaves like
-another iterator, but which modifies some aspect of its behavior.
-For that purpose, the library supplies the <a class="reference" href="iterator_adaptor.html"><tt class="literal"><span class="pre">iterator_adaptor</span></tt></a> class
-template, which is specially designed to take advantage of as much
-of the underlying iterator's behavior as possible.</p>
-<p>Both <a class="reference" href="iterator_facade.html"><tt class="literal"><span class="pre">iterator_facade</span></tt></a> and <a class="reference" href="iterator_adaptor.html"><tt class="literal"><span class="pre">iterator_adaptor</span></tt></a> as well as many of the <a class="reference" href="#specialized-adaptors">specialized
-adaptors</a> mentioned below have been proposed for standardization,
-and accepted into the first C++ technical report; see our</p>
-<blockquote>
-<a class="reference" href="facade-and-adaptor.html">Standard Proposal For Iterator Facade and Adaptor</a></blockquote>
-<p>for more details.</p>
-</div>
-<div class="section" id="specialized-adaptors">
-<h1><a class="toc-backref" href="#id8" name="specialized-adaptors">Specialized Adaptors</a></h1>
-<p>The iterator library supplies a useful suite of standard-conforming
-iterator templates based on the Boost <a class="reference" href="#iterator-facade-and-adaptor">iterator facade and adaptor</a>.</p>
-<ul class="simple">
-<li><a class="reference" href="counting_iterator.html"><tt class="literal"><span class="pre">counting_iterator</span></tt></a>: an iterator over a sequence of consecutive values.
-Implements a &quot;lazy sequence&quot;</li>
-<li><a class="reference" href="filter_iterator.html"><tt class="literal"><span class="pre">filter_iterator</span></tt></a>: an iterator over the subset of elements of some
-sequence which satisfy a given predicate</li>
-<li><a class="reference" href="indirect_iterator.html"><tt class="literal"><span class="pre">indirect_iterator</span></tt></a>: an iterator over the objects <em>pointed-to</em> by the
-elements of some sequence.</li>
-<li><a class="reference" href="permutation_iterator.html"><tt class="literal"><span class="pre">permutation_iterator</span></tt></a>: an iterator over the elements of some random-access
-sequence, rearranged according to some sequence of integer indices.</li>
-<li><a class="reference" href="reverse_iterator.html"><tt class="literal"><span class="pre">reverse_iterator</span></tt></a>: an iterator which traverses the elements of some
-bidirectional sequence in reverse.  Corrects many of the
-shortcomings of C++98's <tt class="literal"><span class="pre">std::reverse_iterator</span></tt>.</li>
-<li><a class="reference" href="transform_iterator.html"><tt class="literal"><span class="pre">transform_iterator</span></tt></a>: an iterator over elements which are the result of
-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>
-</ul>
-</div>
-<div class="section" id="iterator-utilities">
-<h1><a class="toc-backref" href="#id9" name="iterator-utilities">Iterator Utilities</a></h1>
-<div class="section" id="traits">
-<h2><a class="toc-backref" href="#id10" name="traits">Traits</a></h2>
-<ul class="simple">
-<li><a class="reference" href="iterator_traits.html"><tt class="literal"><span class="pre">iterator_traits.hpp</span></tt></a>: Provides <a class="reference" href="../../mpl/doc/index.html">MPL</a>-compatible metafunctions which
-retrieve an iterator's traits.  Also corrects for the deficiencies
-of broken implementations of <tt class="literal"><span class="pre">std::iterator_traits</span></tt>.</li>
-<li><a class="reference" href="interoperable.html"><tt class="literal"><span class="pre">interoperable.hpp</span></tt></a>: Provides an <a class="reference" href="../../mpl/doc/index.html">MPL</a>-compatible metafunction for
-testing iterator interoperability</li>
-</ul>
-</div>
-<div class="section" id="testing-and-concept-checking">
-<h2><a class="toc-backref" href="#id11" name="testing-and-concept-checking">Testing and Concept Checking</a></h2>
-<ul class="simple">
-<li><a class="reference" href="iterator_archetypes.html"><tt class="literal"><span class="pre">iterator_archetypes.hpp</span></tt></a>: Add summary here</li>
-<li><a class="reference" href="iterator_concepts.html"><tt class="literal"><span class="pre">iterator_concepts.hpp</span></tt></a>: Add summary</li>
-</ul>
-</div>
-</div>
-<div class="section" id="upgrading-from-the-old-boost-iterator-adaptor-library">
-<h1><a class="toc-backref" href="#id12" name="upgrading-from-the-old-boost-iterator-adaptor-library">Upgrading from the old Boost Iterator Adaptor Library</a></h1>
-<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="id5" name="id5">[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="#id13" 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>
-<col />
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id5" name="cop95">[Cop95]</a></td><td>[Coplien, 1995] Coplien, J., Curiously Recurring Template
-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 on: 2003-11-24 04:21 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/index.rst

@@ -1,262 +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@ive.uni-hannover.de
-:organizations: `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, 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: 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 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`__
-
-__ new-iter-concepts.html
-
-=============================
- 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 author iterator ensure that his iterator is
-correct.  It is common to define a new iterator which behaves like
-another iterator, but which modifies some aspect of its behavior.
-For that purpose, the library supplies the |adaptor|_ class
-template, which is specially designed to take advantage of as much
-of the underlying iterator's behavior as possible.
-
-.. |facade| replace:: ``iterator_facade``
-.. _facade: iterator_facade.html
-.. |adaptor| replace:: ``iterator_adaptor``
-.. _adaptor: iterator_adaptor.html
-
-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`__
-
-for more details.
-
-__ facade-and-adaptor.html
-
-======================
- Specialized Adaptors
-======================
-
-The iterator library supplies a useful suite of standard-conforming
-iterator templates based on the Boost `iterator facade and adaptor`_.
-
-* |counting|_: an iterator over a sequence of consecutive values.
-  Implements a "lazy sequence"
-
-* |filter|_: an iterator over the subset of elements of some
-  sequence which satisfy a given predicate
-
-* |indirect|_: an iterator over the objects *pointed-to* by the
-  elements of some sequence.
-
-* |permutation|_: an iterator over the elements of some random-access
-  sequence, rearranged according to some sequence of integer indices.
-
-* |reverse|_: an iterator which traverses the elements of some
-  bidirectional sequence in reverse.  Corrects many of the
-  shortcomings of C++98's ``std::reverse_iterator``.
-
-* |transform|_: an iterator over elements which are the result of
-  applying some functional transformation to the elements of an
-  underlying sequence.  This component also replaces the old
-  ``projection_iterator_adaptor``.
-
-.. |counting| replace:: ``counting_iterator``
-.. _counting: counting_iterator.html
-
-.. |filter| replace:: ``filter_iterator``
-.. _filter: filter_iterator.html
-
-.. |indirect| replace:: ``indirect_iterator``
-.. _indirect: indirect_iterator.html
-
-.. |permutation| replace:: ``permutation_iterator``
-.. _permutation: permutation_iterator.html
-
-.. |reverse| replace:: ``reverse_iterator``
-.. _reverse: reverse_iterator.html
-
-.. |transform| replace:: ``transform_iterator``
-.. _transform: transform_iterator.html
-
-====================
- Iterator Utilities
-====================
-
-Traits
-------
-
-* |iterator_traits|_: Provides MPL_\ -compatible metafunctions which
-  retrieve an iterator's traits.  Also corrects for the deficiencies
-  of broken implementations of ``std::iterator_traits``.
-
-* |interoperable|_: Provides an MPL_\ -compatible metafunction for
-  testing iterator interoperability
-
-.. |iterator_traits| replace:: ``iterator_traits.hpp``
-.. _iterator_traits: iterator_traits.html
-
-.. |interoperable| replace:: ``interoperable.hpp``
-.. _interoperable: interoperable.html
-
-.. _MPL: ../../mpl/doc/index.html
-
-Testing and Concept Checking
-----------------------------
-
-* |iterator_archetypes|_: Add summary here
-
-* |iterator_concepts|_: Add summary
-
-.. |iterator_archetypes| replace:: ``iterator_archetypes.hpp``
-.. _iterator_archetypes: iterator_archetypes.html
-
-.. |iterator_concepts| replace:: ``iterator_concepts.hpp``
-.. _iterator_concepts: iterator_concepts.html
-
-
-=======================================================
- 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,362 +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="2003-09-14" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
-<style type="text/css"><!--
-
-/*
-: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 {
-  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 {
-  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.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.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-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-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 }
-
---></style>
-</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>2003-09-14</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"></td>
-</tr>
-</tbody>
-</table>
-<p>The indirect iterator 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>) .</p>
-<!-- At some point we should add the capability to handle
-iterators over smart pointers, which the impl handles. -JGS -->
-<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-requirements" id="id1" name="id1"><tt class="literal"><span class="pre">indirect_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#indirect-iterator-operations" id="id2" name="id2"><tt class="literal"><span class="pre">indirect_iterator</span></tt> operations</a></li>
-</ul>
-</div>
-<pre class="literal-block">
-template &lt;
-    class Iterator
-  , class Value = use_default
-  , unsigned Access  = use_default_access
-  , class Traversal  = use_default
-  , class Reference = use_default
-  , class Difference = use_default
-&gt;
-class indirect_iterator
-  : public iterator_adaptor&lt;/* see discussion */&gt;
-{
-    friend class iterator_core_access;
- public:
-    indirect_iterator();
-    indirect_iterator(Iterator x);
-    template &lt;
-        class Iterator2, class Value2, unsigned Access2, class Traversal2
-      , class Reference2, class Difference2
-    &gt;
-    indirect_iterator(
-        indirect_iterator&lt;
-             Iterator2, Value2, Access2, Traversal2, Reference2, Difference2
-        &gt; const&amp; y
-      , typename enable_if_convertible&lt;Iterator2, Iterator&gt;::type* = 0 // exposition
-    );
-private: // as-if specification
-    typename indirect_iterator::reference dereference() const
-    {
-        return **this-&gt;base();
-    }
-};
-</pre>
-<div class="section" id="indirect-iterator-requirements">
-<h1><a class="toc-backref" href="#id1" 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">value_type</span></tt> of the <tt class="literal"><span class="pre">Iterator</span></tt> template parameter should
-itself be dereferenceable. The return type of the <tt class="literal"><span class="pre">operator*</span></tt> for
-the <tt class="literal"><span class="pre">value_type</span></tt> must be the same type as the <tt class="literal"><span class="pre">Reference</span></tt> template
-parameter. The <tt class="literal"><span class="pre">Value</span></tt> template parameter will be the <tt class="literal"><span class="pre">value_type</span></tt>
-for the <tt class="literal"><span class="pre">indirect_iterator</span></tt>, unless <tt class="literal"><span class="pre">Value</span></tt> is const. If <tt class="literal"><span class="pre">Value</span></tt>
-is <tt class="literal"><span class="pre">const</span> <span class="pre">X</span></tt>, then <tt class="literal"><span class="pre">value_type</span></tt> will be <em>non-</em> <tt class="literal"><span class="pre">const</span> <span class="pre">X</span></tt>.  The
-default for <tt class="literal"><span class="pre">Value</span></tt> is</p>
-<pre class="literal-block">
-iterator_traits&lt; iterator_traits&lt;Iterator&gt;::value_type &gt;::value_type
-</pre>
-<p>If the default is used for <tt class="literal"><span class="pre">Value</span></tt>, then there must be a valid
-specialization of <tt class="literal"><span class="pre">iterator_traits</span></tt> for the value type of the base
-iterator.</p>
-<p>The <tt class="literal"><span class="pre">Reference</span></tt> parameter will be the <tt class="literal"><span class="pre">reference</span></tt> type of the
-<tt class="literal"><span class="pre">indirect_iterator</span></tt>. The default is <tt class="literal"><span class="pre">Value&amp;</span></tt>.</p>
-<p>The <tt class="literal"><span class="pre">Access</span></tt> and <tt class="literal"><span class="pre">Traversal</span></tt> parameters are passed unchanged to
-the corresponding parameters of the <tt class="literal"><span class="pre">iterator_adaptor</span></tt> base
-class, and  the <tt class="literal"><span class="pre">Iterator</span></tt> parameter is passed unchanged as the
-<tt class="literal"><span class="pre">Base</span></tt> parameter to the <tt class="literal"><span class="pre">iterator_adaptor</span></tt> base class.</p>
-<p>The indirect iterator will model the most refined standard traversal
-concept that is modeled by the <tt class="literal"><span class="pre">Iterator</span></tt> type.  The indirect
-iterator will model the most refined standard access concept that is
-modeled by the value type of <tt class="literal"><span class="pre">Iterator</span></tt>.</p>
-</div>
-<div class="section" id="indirect-iterator-operations">
-<h1><a class="toc-backref" href="#id2" 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 base object.</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> that is a copy of <tt class="literal"><span class="pre">y</span></tt>.</td>
-</tr>
-</tbody>
-</table>
-</div>
-</div>
-<hr class="footer" />
-<div class="footer">
-<a class="reference" href="indirect_iterator.rst">View document source</a>.
-Generated on: 2003-11-24 05:00 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/indirect_iterator.rst

@@ -1,23 +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
-
-.. include:: indirect_iterator_ref.rst

doc/indirect_iterator_abstract.rst

@@ -1,8 +0,0 @@
-The 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>``) .
-
-.. At some point we should add the capability to handle
-   iterators over smart pointers, which the impl handles. -JGS

doc/indirect_iterator_ref.rst

@@ -1,127 +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 iterator_adaptor<
-                 indirect_iterator<Iterator, Value, Access, Traversal, 
-                                   Reference, Difference>,
-                 Iterator,
-                 /* Value = see below */,
-                 CategoryOrTraversal,
-                 Reference,
-                 Difference>
-  {
-      friend class iterator_core_access;
-   public:
-      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
-      );
-  private: // as-if specification
-      typename indirect_iterator::reference dereference() const
-      {
-          return **this->base();
-      }
-  };
-
-  template <class Dereferenceable>
-  struct referent {
-    typedef /* see below */ type;
-  };
-
-
-If ``Value`` is not ``use_default`` then the the argument for the
-``iterator_adaptor`` base class' ``Value`` parameter is ``Value`` with
-cv-qualifiers removed. If ``Value`` is ``use_default``, then the
-argument for the ``iterator_adaptor`` base class' ``Value`` parameter
-is computed as follows. We use the abbreviation
-``V=iterator_traits<Iterator>::value_type`` and ``v`` is an object of
-type ``V``.::
-
-    if (*v returns a constant lvalue or an rvalue) then
-        referent<V>::type
-    else
-        add_const<referent<V>::type>::type
-
-The algorithm for the ``type`` member of ``referent`` traits class is
-as follows::
-
-    if (Dereferenceable is a class and has member element_type)
-        Dereferenceable::element_type
-    else
-        iterator_traits<Dereferenceable>::value_type
-
-
-``indirect_iterator`` requirements
-..................................
-
-The ``CategoryOrTraversal`` argument shall be one of the standard
-iterator tags or ``use_default``. If ``CategoryOrTraversal`` is an
-iterator tag, ``indirect_iterator`` satisfies the requirements
-corresponding to the iterator tag.  The template parameter
-``Iterator`` argument shall meet the traversal requirements
-corresponding to the iterator tag and the requirements of Readable
-Iterator.  If ``CategoryOrTraversal`` is ``use_default`` then
-``indirect_iterator`` satisfies the requirements of the most refined
-standard traversal concept that is satisfied by the ``Iterator``
-argument. In this case the ``Iterator`` argument shall meet the
-requirements of Readable Iterator.
-
-The expression ``*v``, where ``v`` is an object of type
-``iterator_traits<Iterator>::value_type``, must be a valid expression
-and must be convertible to ``iterator_adaptor::reference`` Also, 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.
-
-
-
-``indirect_iterator`` operations
-................................
-
-``indirect_iterator();``
-
-:Requires: ``Iterator`` must be Default Constructible.
-:Returns: An instance of ``indirect_iterator`` with 
-   a default-constructed ``iterator_adaptor`` subobject.
-
-
-``indirect_iterator(Iterator x);``
-
-:Returns: An instance of ``indirect_iterator`` with
-    the ``iterator_adaptor`` subobject 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``.
-:Returns: An instance of ``indirect_iterator`` whose 
-    ``iterator_adaptor`` subobject is constructed from ``y.base()``.
-
-

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/iter-issue-list.rst

@@ -1,942 +0,0 @@
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- Our Personal Iterator Issue List
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-.. _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
-
-
-problem with is_writable, is_swappable
-======================================
-
-See the separate writeup_.
-
-.. _writeup: ./issues.html
-
-
-reference requirements in readable iterator
-===========================================
-
-The DR has been submitted. This is a placeholder for updating our
-proposals with respects to the resolution of that DR.
-
-
-Subject: N1550: iterator_access overspecified?
-==============================================
-Date: Fri, 07 Nov 2003 10:25:45 -0500
-Message c++std-lib-12262
-
-The proposal includes:
- 
-enum iterator_access { readable_iterator = 1, writable_iterator = 2,
-swappable_iterator = 4, lvalue_iterator = 8 };
- 
-In general, the standard specifies thing like this as a bitmask type with a
-list of defined names, and specifies neither the exact type nor the
-specific values. Is there a reason for iterator_access to be more specific?
-
-
-Resolution
-----------
-
-The iterator_access enum has been removed, so this is no longer an issue.
-
-
-
-
-N1530: Minor Issues
-===================
-Message c++std-lib-12299
-Date: Tue, 11 Nov 2003 10:30:36 -0500
-
-1. operators of iterator_facade overspecified. In general, we've provided 
-operational semantics for things like operator++. That is, we've said that 
-++iter must work, without requiring either a member function or a 
-non-member function. iterator_facade specifies most operators as member 
-functions. There's no inherent reason for these to be members, so we should 
-remove this requirement. Similarly, some operations are specified as 
-non-member functions but could be implemented as members. Again, the 
-standard doesn't make either of these choices, and TR1 shouldn't, either. 
-So: operator*(), operator++(), operator++(int), operator--(), 
-operator--(int), operator+=, operator-=, operator-(difference_type), 
-operator-(iterator_facade instance), and operator+ should be specified with 
-operational semantics and not explicitly required to be members or non-members.
-
-2. enable_if_interoperable needs standardese. The only discussion of what 
-this means is in a note, so is non-normative. Further, the note seems to be 
-incorrect. It says that enable_if_interoperable only works for types that 
-"are interoperable, by which we mean they are convertible to each other." 
-This requirement is too strong: it should be that one of the types is 
-convertible to the other.
-
-3. iterator_adaptor has an extraneous 'bool' at the start of the template 
-definition.
-
-4. iterator_adaptor has a private member named m_iterator. Presumably this 
-is for exposition only, since it's an implementation detail. It needs to be 
-marked as such.
-
-5. iterator_adaptor operations specifications are a bit inconsistent. 
-iterator_adpator() has a Requires clause, that Base must be default 
-constructible. iterator_adaptor(Base) has no Requires clause, although the 
-Returns clause says that the Base member is copy construced from the 
-argument (this may actually be an oversight in N1550, which doesn't require 
-iterators to be copy constructible or assignable).
-
-6. similar to 2, "Specialized Adaptors" has a note describing 
-enable_if_convertible. This should be normative text.
-
-7. reverse iterator "flips the direction of the base iterator's motion". 
-This needs to be more formal, as in the current standard. Something like: 
-"iterates through the controlled sequence in the opposite direction"
-
-8. reverse_iterator::dereference is specified as calling a function named 
-'prior' which has no specification.
-
-9. Transform iterator has a two-part specification: it does this, in other 
-words, it does that. "In other words" always means "I didn't say it right, 
-so I'll try again." We need to say it once.
-
-10. similar to 4, transform_iterator has a private member named 'm_f' which 
-should be marked "exposition only."
-
-11. The description of Counting iterator is unclear. "The counting iterator 
-adaptor implements dereference by returning a reference to the base object. 
-The other operations are implemented by the base m_iterator, as per the 
-inheritance from iterator_adaptor."
-
-12. Counting iterator has the following note:
-
-[Note: implementers are encouraged to provide an implementation of 
-distance_to and a difference_type that avoids overflows in the cases when 
-the Incrementable type is a numeric type.]
-
-I'm not sure what this means. The user provides a template argument named 
-Difference, but there's no difference_type. I assume this is just a glitch 
-in the wording. But if implementors are encouraged to ignore this argument 
-if it won't work right, why is it there?
-
-
-Subject: N1550: iterator_facade Derived template argument underspecified
-========================================================================
-Message c++std-lib-12302,
-Date: Wed, 12 Nov 2003 11:16:49 -0500
- 
-The first template argument to iterator_facade is named Derived, and the
-proposal says:
- 
-        The Derived template parameter must be a class derived from iterator_facade.
- 
-First, iterator_facade is a template, so cannot be derived from. Rather,
-the class must be derived from a specialization of iterator_facade. More
-important, isn't Derived required to be the class that is being defined?
-That is, if I understand it right, the definition of D here this is not valid:
- 
-class C : public iterator_facade<C, ... > { ... };
- 
-class D : public iterator_facade<C, ...> { ... };
- 
-In the definition of D, the Derived argument to iterator_facade is a class
-derived from a specialization of iterator_facade, so the requirement is
-met. Shouldn't the requirement be more like "when using iterator_facade to
-define an iterator class Iter, the class Iter must be derived from a
-specialization of iterator_facade whose first template argument is Iter."
-That's a bit awkward, but at the moment I don't see a better way of
-phrasing it.
-
-
-Subject: N1550: return type of Iterator difference for iterator facade
-======================================================================
-Date: Wed, 12 Nov 2003 12:20:26 -0500
-Message c++std-lib-12303
- 
-The proposal says:
- 
->template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
->           class Dr2, class V2, class AC2, class TC2, class R2, class D2>
->typename enable_if_interoperable<Dr1, Dr2, bool>::type
->operator -(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
->            iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
- 
-Shouldn't the return type be one of the two iterator types? Which one? The
-idea is that if one of the iterator types can be converted to the other
-type, then the subtraction is okay. Seems like the return type should then
-be the type that was converted to. Is that right?
-
-
-
-Subject: N1550: Minor Wording Issue
-=================================== 
-Date: Wed, 12 Nov 2003 13:19:07 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12305
- 
-In the table that lists the required (sort of) member functions of iterator
-types that are based on iterator_facade, the entry for c.equal(y) says:
- 
->true iff c and y refer to the same position. Implements c == y and c != y.
- 
-The second sentence is inside out. c.equal(y) does not implement either of
-these operations. It is used to implement them. Same thing in the
-description of c.distance_to(z).
-
-
-Subject: N1530: Problems in iterator facade operations
-======================================================
-Date: Wed, 12 Nov 2003 13:52:55 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12308
- 
-1. Several of the descriptions use the name X without defining it. This
-seems to be a carryover from the table immediately above this section, but
-the text preceding that table says "In the table below, X is the derived
-iterator type." Looks like the X:: qualifiers aren't really needed;
-X::reference can simply be reference, since that's defined by the
-iterator_facade specialization itself.
- 
-2. Several of the member functions return a Derived object or a Derived&.
-Their Effects clauses end with
-
-::
-    
-    return *this;
-
-This should be
-
-::
-
-    return *(Derived*)this;
-    
-
-3. The returns clause for operator[](difference_type n) const says
-
-::
-
-    Returns: an object convertible to X::reference and holding a copy p of a+n
-    such that, for a constant object v of type X::value_type,
-    X::reference(a[n] = v) is equivalent to p = v.
-    
-This needs to define 'a', but assuming it's supposed to be *this (or
-maybe *(Derived*)this), it still isn't clear what this
-says. Presumably, the idea is that you can index off of an iterator
-and assign to the result. But why the requirement that it hold a copy
-of a+n? Granted, that's probably how it's implemented, but it seems
-over-constrained. And the last phrase seems wrong. p is an iterator;
-there's no requirement that you can assign a value_type object to
-it. Should that be *p = v? But why the cast in reference(a[n] = v)?
- 
-4. operator- has both an effects clause and a returns clause. Looks like
-the returns clause should be removed.
-
-
-Subject: N1530: Problems in indirect_iterator operations
-========================================================
-Date: Wed, 12 Nov 2003 14:49:44 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12310
- 
-1. The default constructor returns "An instance of indirect_iterator with a
-default constructed base object", but the constructor that takes an
-Iterator object returns "An instance of indirect_iterator with the
-iterator_adaptor subobject copy constructed from x." The latter is the
-correct form, since it does not reach inside the base class for its
-semantics. So the default constructor shoudl return "An instance of
-indirect_iterator with a default-constructed iterator_adaptor subobject."
- 
-2. The templated constructor that takes an indirect_iterator with a
-different set of template arguments says that it returns "An instance of
-indirect_iterator that is a copy of [the argument]". But the type of the
-argument is different from the type of the object being constructed, and
-there is no description of what a "copy" means. The Iterator template
-parameter for the argument must be convertible to the Iterator template
-parameter for the type being constructed, which suggests that the
-argument's contained Iterator object should be converted to the target
-type's Iterator type. Is that what's meant here?
-
-
-Resolution
-----------
-
-1. As suggested, change the returns clause to read:
-
-:Returns: An instance of ``indirect_iterator`` with a default-constructed
-  ``iterator_adaptor`` subobject.
-
-
-2. Basically, yes. The return clause should be changed to:
-
-:Returns: An instance of ``indirect_iterator`` whose 
-  ``iterator_adaptor`` subobject is constructed from ``y.base()``.
-
-
-
-Subject: N1530: enable_if_convertible conflicts with requires
-=============================================================
-Date: Wed, 12 Nov 2003 15:09:48 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12312
- 
-In every place where enable_if_convertible is used it's used like this
-(simplified):
- 
-template<class T>
-struct C
-{
-template<class T1>
-C(T1, enable_if_convertible<T1, T>::type* = 0);
-};
- 
-The idea being that this constructor won't compile if T1 isn't convertible
-to T. As a result, the constructor won't be considered as a possible
-overload when constructing from an object x where the type of x isn't
-convertible to T. In addition, however, each of these constructors has a
-requires clause that requires convertibility, so the behavior of a program
-that attempts such a construction is undefined. Seems like the
-enable_if_convertible part is irrelevant, and should be removed.
-
-
-Subject: N1530: transform_iterator argument irregularity
-========================================================
-Date: Wed, 12 Nov 2003 15:22:58 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12315
- 
-The specialized adaptors that take both a Value and a Reference template
-argument all take them in that order, i.e. Value precedes Reference in the
-template argument list, with the exception of transform_iterator, where
-Reference precedes Value. This seems like a possible source of confusion.
-Is there a reason why this order is prefereable?
-
-
-Subject: N1530: function_output_iterator
-======================================== 
-Date: Wed, 12 Nov 2003 15:52:37 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12318
- 
-1. function_output_iterator requirements says: "The UnaryFunction must be
-Assignable, Copy Constructible, and the expression f(x) must be valid,
-where f is an object of type UnaryFunction and x is an object of a type
-accepted by f."
- 
-Everything starting with "and," somewhat reworded, is actually a constraint
-on output_proxy::operator=. All that's needed to create a
-function_output_iterator object is that the UnaryFunction type be
-Assignable and CopyConstructible. That's also sufficient to dereference and
-to increment such an object. It's only when you try to assign through a
-dereferenced iterator that f(x) has to work, and then only for the
-particular function object that the iterator holds and for the particular
-value that is being assigned.
- 
-2. Should output_proxy really be a named type? This means someone can store
-an output_proxy object for later use, whatever that means. It also
-constrains output_proxy to hold a copy of the function object, rather than
-a pointer to the iterator object. Is all this mechanism really necessary?
- 
-
-
-N1550: istreambuf_iterator isn't a Readable Iterator
-====================================================
-Date: Thu, 13 Nov 2003 08:24:39 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12333
- 
-N1550 requires that for a Readable Iterator a of type X, *a returns an
-object of type iterator_traits<X>::reference.
-istreambuf_iterator::operator* returns charT, but
-istreambuf_iterator::reference is charT&. So am I overlooking something, or
-is istreambuf_iterator not Readable?
-
-
-
-
-Subject: N1530: iterator_facade free functions unspecified
-========================================================== 
-Date: Tue, 02 Dec 2003 14:44:05 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12562
-
-
-The template functions operator==, operator!=, operator<, operator<=,
-operator>, operator>=, and operator- that take two arguments that are
-specializations of iterator_facade have no specification. The template
-function operator+ that takes an argument that is a specialization of
-iterator_facade and an argument of type difference_type has no specification.
-
-
-
-
-Subject: N1530, iterator_facade: too many equals?
-=================================================
-Date: Tue, 02 Dec 2003 17:24:55 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12563
-
- 
-The table listing the functions required for types derived from
-iterator_facade has two functions named equal and two named distance_to::
-
-    c.equal(b)
-    c.equal(y)
- 
-    c.distance_to(b)
-    c.distance_to(z)
- 
-where b and c are const objects of the derived type, y and z are constant
-objects of certain iterator types that are interoperable with the derived type.
- 
-Seems like the 'b' versions are redundant: in both cases, the other version
-will take a 'b'. In fact, iterator_adaptor is specified to use
-iterator_facade, but does not provide the 'b' versions of these functions.
- 
-Are the 'b' versions needed?
-
-
-
-Subject: Re: Proposed revision of N1550
-=======================================
-From: Pete Becker <petebecker@acm.org>
-Date: Wed, 03 Dec 2003 13:36:26 -0500
-Message c++std-lib-12566
-
-The footnote says:
- 
->The UnaryTypeTrait concept is defined in n1519; the LWG added the
->requirement that specializations are derived from their nested ::type.
- 
-This is not correct. We had a vague discussion of this in Kona and agreed
-in principle, but at the time there was no formal proposal. It's in the
-issues list as a new issue.
-
-
-Subject: Re: Proposed revision of N1550
-=======================================
-Date: Fri, 5 Dec 2003 15:09:32 -0500
-From: Howard Hinnant <hinnant@twcny.rr.com>
-Message c++std-lib-12585
-
-I'm wading thru
-
-http://boost-consulting.com/boost/libs/iterator/doc/new-iter-concepts.html
-
-and due to my desire to plow through this in a sequential manner, I'm  
-having trouble getting past one spot.  I've skimmed through the  
-previous discussions and didn't see that this issue was addressed  
-(sorry if I missed it).
-
-Readable Iterator Requirements says::
-
-    a->m      U&        pre: (*a).m is well-defined. Equivalent to (*a).m
-
-Do we mean to outlaw iterators with proxy references from meeting the  
-readable requirements?
-
-Consider::
-
-    template <class T>
-    class proxy_pointer
-    {
-    public:
-	 proxy_pointer(T* t) : t_(t) {}
-
-	 T* operator->() {return t_;}
-    private:
-	 T* t_;
-    };
-
-    template <class T>
-    class proxy_reference
-    {
-    public:
-	 proxy_reference(T& t) : t_(&t) {}
-
-	 proxy_reference& operator=(const T& t)
-	 {
-	     *t_ = t;
-	     return *this;
-	 }
-
-	 proxy_reference& operator=(const proxy_reference& p)
-	 {
-	     *t_ = p->t_;
-	     return *this;
-	 }
-
-	 operator T() const {return *t_;}
-
-	 proxy_pointer<T> operator&() const {return proxy_pointer<T>(t_);}
-    private:
-	 T* t_;
-    };
-
-    template <class T>
-    class iterator
-    {
-    public:
-	 typedef proxy_reference<T> reference;
-	 typedef proxy_pointer<T> pointer;
-
-	 iterator(T* t) : t_(t) {}
-	 reference operator*() const {return reference(*t_);}
-	 pointer operator->() const {return pointer(t_);}
-    private:
-	 T* t_;
-    };
-
-    int main()
-    {
-	 typedef std::pair<int, int> T;
-	 T p(1, 2);
-	 iterator<T> r(&p);
-	 int i = (*r).first;  // error
-	 int j = r->first;  // ok
-    }
-
-Would it be better for the requirements to read static_cast<T>(*a).m  
-instead of (*a).m ?
-
-
-Subject: N1530: counting_iterator Traversal argument unspecified
-================================================================
-Date: Tue, 09 Dec 2003 10:09:15 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12635
- 
-counting_iterator takes an argument for its Traversal type, with a default
-value of use_default. It is derived from an instance of iterator_adaptor,
-where the argument passed for the Traversal type is described as "/* see
-details for traversal category */". The details for counting_iterator
-describe constraints on the Incrementable type imposed by various traversal
-categories. There is no description of what the argument to
-iterator_adaptor should be.
-
-
-Subject: N1530: iterator_facade function requirements
-=====================================================
-Date: Tue, 09 Dec 2003 10:47:40 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12636
- 
-The table that lists required functions for the derived type X passed to
-iterator_facade lists, among others:
- 
-for a single pass iterator:
-c.equal(b)
-c.equal(y)
- 
-where b and c are const X objects, and y is a const object of a single pass
-iterator that is interoperable with X. Since X is interoperable with
-itself, c.equal(b) is redundant. There is a difference in their
-descriptions, but its meaning isn't clear. The first is "true iff b and c
-are equivalent", and the second is "true iff c and y refer to the same
-position." Is there a difference between the undefined term "equivalent"
-and "refer to the same position"?
- 
-Similarly, for a random access traversal iterator:
-c.distance_to(b)
-c.distance_to(z)
- 
-where z is a constant object of a random access traversal iterator that is
-interoperable with X. Again, X is interoperable with itself, so
-c.distance_to(b) is redundant.
- 
-Also, the specification for c.distance_to(z) isn't valid. It's written as
-"equivalent to distance(c, z)". The template function distance takes two
-arguments of the same type, so distance(c, z) isn't valid if c and z are
-different types. Should it be distance(c, (X)z)?
-
-
-
-Subject: N1530: iterator_facade requirements muddled
-====================================================
-Date: Tue, 09 Dec 2003 11:20:00 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12638
-
-Sorry for the title. The problem is that the section entitled 
-"iterator_facade requirements" mixes specification of the implementation 
-with specification of constraints on user-supplied types. The specification 
-of the implementation isn't really need, though. Paragraph by paragraph:
-
->Some of the constraints on template parameters to iterator_facade are 
->expressed in terms of resulting nested types and should be viewed in the 
->context of their impact on iterator_traits<Derived>.
-
-This isn't really true, once we go through the rest. Remove it.
-
->The Derived template parameter must be a class derived from iterator_facade.
-
-There's already an open issue on the wording here. No other changes needed.
-
->The nested ::value_type type will be the same as remove_cv<Value>::type, 
->so the Value parameter must be an (optionally const-qualified) 
->non-reference type.
-
-The first clause repeats what's already said in the definition of the 
-template. The second clause is the important part. Rewrite as:
-
-The Value parameter shall be an optionally const-qualified non-reference type.
-
->AccessCategory must be an unsigned value which uses no more bits than the 
->greatest value of iterator_access.
-
-There's an open issue in N1550 about the specification of access 
-categories. The standard defines "bitmask type" for this purpose. Using it 
-removes the problem of determining what "uses no more bits" means.
-
->The nested ::reference will be the same as the Reference parameter; it 
->must be a suitable reference type for the resulting iterator. The default 
->for the Reference parameter is Value&.
-
-The first clause repeats what's already said in the definition of the 
-template. The second clause has no technical meaning. The last sentence is 
-part of the specification of the template, and should be moved to the 
-definition of the template. Remove this paragraph, and change the template 
-argument in the definition of iterator_facade from
-
-         class Reference = /* see below */
-
-to
-
-         class Reference = Value&;
-
-Finally, something that isn't quite as clearcut:
-
->Depending on the resulting iterator's iterator_category, a subset of the 
->expressions listed in the table are required to be valid.
-
-Is it meaningful to have an iterator that is neither readable nor writable? 
-If not, then this can be phrased as "Depending on the template argument 
-TraversalCategory", and the first line of the following table can be 
-removed from the table and stated as an overall requirement.
-
-
-
-
-
-Subject: N1530: iterator_adaptor issues
-=======================================
-Date: Tue, 09 Dec 2003 12:36:44 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12639
-
-
-1. The Derived argument seems to be underspecified. Same problem as 
-described in N1541, 9.21 for iterator_facade.
-
-2. The name Base for the iterator that's being adapted (and in the member 
-functions base() and base_reference()) is confusing, since it's not a base 
-in the sense that the term is used in C++. The templates indirect_iterator 
-and reverse_iterator both name their iterator argument Iterator. We should 
-do the same here.
-
-3. The clause entitled "iterator_adaptor requirements" talks about 
-iterator_traits<Derived>::iterator_category. The base iterator_facade 
-defines iterator_category, so it would seem more natural to simply use 
-that. Unless, of course, Derived is permitted to provide its own definition 
-of iterator_category which is different from the one in the base, or that 
-iterator_traits<Derived> can be specialized to provide a differnt one. That 
-doesn't seem reasonable, since the type in the base is determined by the 
-Access and Traversal arguments that the user passed to iterator_adaptor. 
-Why would the user want to define it differently?
-
-4. The clause entitled "iterator_adaptor requirements" sets out 
-requirements in terms of the typedefs defined in iterator_facade. It would 
-be clearer to specify the arguments that should be passed to iterator_facade:
-
-Value argument to iterator_facade::
-
-    if (Value != use_default)
-        Value
-    else
-        iterator_traits<Base>::value_type
-
-But note that the default here is slightly different from the default 
-specified in the paper. The latter can't be implemented correctly with an 
-argument to iterator_facade, since iterator_traits<Base>::value_type might 
-be cv-qualified, and iterator_facade strips the cv-qualifier. The approch 
-I've given strips the cv-qualifier, too. In order to implement what the 
-paper says, iterator_adaptor would have to provide its own version of 
-value_type.
-
-AccessCategory argument to iterator_facade::
-
-    if (Access != use_default)
-	Access
-    else if (is_const<Value>)
-	access_category<Base>::value & ~writable_iterator
-    else
-	access_category<Base>::value
-
-This assumes (as does the paper) that there is a suitable definition of 
-access_category somewhere (N1550 doesn't specify it).
-
-TraversalCategory argument to iterator_facade::
-
-    if (Traversal != use_default)
-	Traversal
-    else
-	traversal_category<Base>::type
-
-This assumes (as does the paper) that there is a suitable definition of 
-traversal_category somewhere (N1550 doesn't specify it).
-
-iterator_category is redundant and should be removed.
-
-Reference argument to iterator_facade::
-
-    if (Reference != use_default)
-        Reference
-    else if (Value != use_default)
-        Value&
-    else
-        iterator_traits<Base>::reference
-
-The Difference argument to iterator_facade isn't specified here. Needs to 
-be added. By analogy, should it be this?::
-
-    if (Difference != use_default)
-	Difference
-    else
-	iterator_traits<Base>::difference_type
-
-
-
-
-
-Subject: N1530: indirect_iterator requirements muddled
-======================================================
-Date: Tue, 09 Dec 2003 13:35:20 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12640
-
-
-Part 1
-------
-
->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.
-
-I'd say this a bit differently, to emphasize what's required:
-
-iterator_traits<Iterator>::value_type must be dereferenceable.
-
-The Reference template parameter must be the same type as 
-*iterator_traits<Iterator>::value_type().
-
-
-Resolution
-----------
-
-I don't think we want to require default constructible for
-``iterator_traits<Iterator>::value_type``, so I've reworded to avoid
-that implication.
-
-Change the text to:
-
-The following requirements are placed on the type
-``iterator_traits<Iterator>::value_type``. Let ``i`` be an object of
-type ``iterator_traits<Iterator>::value_type``.  Then ``*i`` must be a
-valid expression, and the type of ``*i`` must be the same as the
-``Reference`` template parameter.
-
-Part 2
-------
-
->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.
-
-Also non-volatile, right? In other words, if Value isn't use_default, it 
-just gets passed as the Value argument for iterator_adaptor.
-
-
-Resolution
-----------
-
-Yes, I think that's right. Dave, can you confirm?
-
-Here's the rewording:
-
-The ``Value`` template parameter will be the ``value_type`` for the
-``indirect_iterator``, unless ``Value`` is cv-qualified. If ``Value``
-is cv-qualified then ``value_type`` will be non-qualified version of
-the type.
-
-
-Part 3
-------
-
->The default for Value is
->
->iterator_traits< iterator_traits<Iterator>::value_type >::value_type
->
->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.
-
-The earlier requirement is that iterator_traits<Iterator>::value_type must 
-be dereferenceable. Now it's being treated as an iterator. Is this just a 
-pun, or is iterator_traits<Iterator>::value_type required to be some form 
-of iterator? If it's the former we need to find a different way to say it. 
-If it's the latter we need to say so.
-
-
-Resolution
-----------
-
-Dave, help!
-
-
-Part 4
-------
-
->The Reference parameter will be the reference type of the 
->indirect_iterator. The default is Value&.
-
-That is, the Reference parameter is passed unchanged as the Reference 
-argument to iterator_adaptor. Which is what it should say, instead of 
-repeating what iterator_adaptor does.
-
-Resolution
-----------
-
-Yes.
-
-
-Part 5
-------
-
->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.
-
-Okay, but wordy. We should put it in the template definition:
-
-template<
-         class Iterator,
-         class Value = use_default,
-         class Access = use_default_access,
-         class Traversal = use_default,
-         class Reference = use_default,
-         clsas Difference = use_default>
-class indirect_iterator
-         : public iterator_adaptor<
-                 indirect_iterator<Iterator, Value, Access, Traversal, 
-Reference, Difference>,
-                 Iterator,
-                 /* Value = see below */,
-                 Access,
-                 Traversal,
-                 Reference,
-                 Difference>
-
-Resolution
-----------
-
-Yes.
-
-
-Part 6
-------
-
->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.
-
-That's not strictly true. The Access and Traversal arguments can be more 
-restrictive than the Iterator, in which case the operations needed for the 
-most refined types are available, but iterator_traits<X>::iterator_category 
-won't reflect those capabilities.
-
-
-Resolution
-----------
-
-The indirect iterator will model the most refined standard traversal
-concept that is modeled by the ``Iterator`` type and that refines the
-traversal category specified in the ``CategoryOrTraversal`` parameter.
-The indirect iterator will model the most refined standard access
-concept that is modeled by the value type of ``Iterator``.
-
-.. I am not confident in the above. -JGS
-
-
-Subject: N1530: transform_iterator requirements
-===============================================
-Date: Tue, 09 Dec 2003 13:42:49 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12641
- 
->The reference type of transform_iterator is
->result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type. The
->value_type is remove_cv<remove_reference<reference> >::type.
- 
-These are the defaults, right? If the user supplies their own types that's
-what gets passed to iterator_adaptor. And again, the specification should
-be in terms of the specialization of iterator_adaptor, and not in terms of
-the result:
- 
-Reference argument to iterator_adaptor::
-
-    if (Reference != use_default)
-	Reference
-    else
-	result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type
-
-Value argument to iterator_adaptor::
-
-    if (Value != use_default)
-	Value
-    else if (Reference != use_default)
-	remove_reference<reference>::type
-    else
-	remove_reference<result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type>::type
- 
-There's probably a better way to specify that last alternative, but I've
-been at this too long, and it's all turning into a maze of twisty passages,
-all alike.
-
-
- 
-Subject: N1530: filter_iterator details unspecified
-===================================================
-Date: Tue, 09 Dec 2003 13:52:21 -0500
-From: Pete Becker <petebecker@acm.org>
-Message c++std-lib-12642
- 
-The paper says::
-
-    template<class Predicate, class Iterator>
-    class filter_iterator
-	     : public iterator_adaptor<
-		     filter_iterator<Predicate, Iterator>,
-		     Iterator,
-		     use_default,
-		     /* see details */ >
- 
-That comment covers the Access, Traversal, Reference, and Difference
-arguments. The only specification for any of these in the details is:
- 
->The access category of the filter_iterator will be the same as the access
->category of Iterator.
- 
-Needs more.
-
-

doc/iterator_adaptor.html

@@ -1,525 +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 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="2003-09-14" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
-<style type="text/css"><!--
-
-/*
-: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 {
-  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 {
-  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.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.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-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-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 }
-
---></style>
-</head>
-<body>
-<div class="document" id="iterator-adaptor">
-<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>2003-09-14</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"></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"><a name="table-of-contents">Table of Contents</a></p>
-<ul class="simple">
-<li><a class="reference" href="#introduction" id="id3" name="id3">Introduction</a></li>
-<li><a class="reference" href="#reference" id="id4" name="id4">Reference</a><ul>
-<li><a class="reference" href="#iterator-adaptor-base-class-parameters" id="id5" name="id5"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> base class parameters</a></li>
-<li><a class="reference" href="#iterator-adaptor-usage" id="id6" name="id6"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> usage</a></li>
-<li><a class="reference" href="#iterator-adaptor-public-operations" id="id7" name="id7"><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="id8" name="id8"><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="id9" name="id9"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> private member functions</a></li>
-</ul>
-</li>
-</ul>
-</div>
-<div class="section" id="introduction">
-<h1><a class="toc-backref" href="#id3" name="introduction">Introduction</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 class="fn-backref" href="#id1" name="base">[1]</a></td><td>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 table
-above. The <tt class="literal"><span class="pre">Base</span></tt> type need not meet the full requirements for an
-iterator. It need only support the operations used by the core
-interface functions of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> that have not been
-redefined in the user's derived class.</p>
-<p>Several of the template parameters of <tt class="literal"><span class="pre">iterator_adaptor</span></tt> default
-to <tt class="literal"><span class="pre">use_default</span></tt>. This allows the
-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="#id4" 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 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">
-<h2><a class="toc-backref" href="#id5" 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>
-</div>
-<div class="section" id="iterator-adaptor-usage">
-<h2><a class="toc-backref" href="#id6" name="iterator-adaptor-usage"><tt class="literal"><span class="pre">iterator_adaptor</span></tt> usage</a></h2>
-<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">``\</span> <span class="pre">*V*\</span></tt>, <tt class="literal"><span class="pre">\</span> <span class="pre">*C*\</span></tt>, <tt class="literal"><span class="pre">\</span> <span class="pre">*R*\</span></tt>, <tt class="literal"><span class="pre">\</span>
-<span class="pre">*D*\</span></tt>&gt;`` 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">
-<h2><a class="toc-backref" href="#id7" 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">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="#id8" 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="#id9" 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>
-<hr class="footer" />
-<div class="footer">
-<a class="reference" href="iterator_adaptor.rst">View document source</a>.
-Generated on: 2003-11-24 05:11 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.rst

@@ -1,32 +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
-
-Introduction
-============
-
-.. include:: iterator_adaptor_body.rst
-
-
-Reference
-=========
-
-.. include:: iterator_adaptor_ref.rst

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.rst

@@ -1,39 +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 table
-above. The ``Base`` type need not meet the full requirements for an
-iterator. It need only support the operations used by the core
-interface functions of ``iterator_adaptor`` that have not been
-redefined in the user's derived class.
-
-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.rst

@@ -1,169 +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 base() const;
-   protected:
-      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_
-
-.. _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`` usage
---------------------------
-
-The ``Derived`` template parameter must be a publicly derived from
-``iterator_adaptor``.  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.
-
-``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 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_facade.html

@@ -1,832 +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 Facade</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="2003-09-14" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
-<style type="text/css"><!--
-
-/*
-: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 {
-  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 {
-  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.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.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-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-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 }
-
---></style>
-</head>
-<body>
-<div class="document" id="iterator-facade">
-<h1 class="title">Iterator Facade</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>2003-09-14</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"></td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">iterator_facade</span></tt> 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.</p>
-<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="#motivation" id="id7" name="id7">Motivation</a></li>
-<li><a class="reference" href="#usage" id="id8" name="id8">Usage</a></li>
-<li><a class="reference" href="#iterator-core-access" id="id9" name="id9">Iterator Core Access</a></li>
-<li><a class="reference" href="#operator" id="id10" name="id10"><tt class="literal"><span class="pre">operator[]</span></tt></a></li>
-<li><a class="reference" href="#id2" id="id11" name="id11"><tt class="literal"><span class="pre">operator-&gt;</span></tt></a></li>
-<li><a class="reference" href="#reference" id="id12" name="id12">Reference</a><ul>
-<li><a class="reference" href="#iterator-facade-usage" id="id13" name="id13"><tt class="literal"><span class="pre">iterator_facade</span></tt> usage</a></li>
-<li><a class="reference" href="#iterator-facade-iterator-category" id="id14" name="id14"><tt class="literal"><span class="pre">iterator_facade</span></tt> iterator category</a></li>
-<li><a class="reference" href="#iterator-facade-operations" id="id15" name="id15"><tt class="literal"><span class="pre">iterator_facade</span></tt> operations</a></li>
-</ul>
-</li>
-</ul>
-</div>
-<div class="section" id="motivation">
-<h1><a class="toc-backref" href="#id7" name="motivation">Motivation</a></h1>
-<!-- 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 -->
-<p>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:</p>
-<ul class="simple">
-<li>dereferencing</li>
-<li>incrementing</li>
-<li>decrementing</li>
-<li>equality comparison</li>
-<li>random-access motion</li>
-<li>distance measurement</li>
-</ul>
-<p>In addition to the behaviors listed above, the core interface elements
-include the associated types exposed through iterator traits:
-<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">difference_type</span></tt>, and
-<tt class="literal"><span class="pre">iterator_category</span></tt>.</p>
-<p>Iterator facade uses the Curiously Recurring Template Pattern (CRTP)
-<a class="citation-reference" href="#cop95" id="id1" name="id1">[Cop95]</a> so that the user can specify the behavior of
-<tt class="literal"><span class="pre">iterator_facade</span></tt> in a derived class.  Former designs used policy
-objects to specify the behavior.  <tt class="literal"><span class="pre">iterator_facade</span></tt> does not use policy
-objects for several reasons:</p>
-<blockquote>
-<ol class="arabic simple">
-<li>the creation and eventual copying of the policy object may create
-overhead that can be avoided with the current approach.</li>
-<li>The policy object approach does not allow for custom constructors
-on the created iterator types, an essential feature if
-<tt class="literal"><span class="pre">iterator_facade</span></tt> should be used in other library
-implementations.</li>
-<li>Without the use of CRTP, the standard requirement that an
-iterator's <tt class="literal"><span class="pre">operator++</span></tt> returns the iterator type itself means
-that all iterators generated by <tt class="literal"><span class="pre">iterator_facade</span></tt> would be
-specializations of <tt class="literal"><span class="pre">iterator_facade</span></tt>.  Cumbersome type generator
-metafunctions would be needed to build new parameterized
-iterators, and a separate <tt class="literal"><span class="pre">iterator_adaptor</span></tt> layer would be
-impossible.</li>
-</ol>
-</blockquote>
-</div>
-<div class="section" id="usage">
-<h1><a class="toc-backref" href="#id8" name="usage">Usage</a></h1>
-<p>The user of <tt class="literal"><span class="pre">iterator_facade</span></tt> derives his iterator class from an
-specialization of <tt class="literal"><span class="pre">iterator_facade</span></tt> which takes the derived iterator
-class as the first template parameter.  The order of the other
-template parameters to <tt class="literal"><span class="pre">iterator_facade</span></tt> 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 <tt class="literal"><span class="pre">value_type</span></tt> as <tt class="literal"><span class="pre">iterator_facade</span></tt>'s <tt class="literal"><span class="pre">Value</span></tt>
-parameter and omit the <tt class="literal"><span class="pre">Reference</span></tt> parameter which follows.</p>
-<p>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.</p>
-<blockquote>
-<table border class="table">
-<colgroup>
-<col width="44%" />
-<col width="56%" />
-</colgroup>
-<thead valign="bottom">
-<tr><th>Expression</th>
-<th>Effects</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr><td><tt class="literal"><span class="pre">i.dereference()</span></tt></td>
-<td>Access the value referred to</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">i.equal(j)</span></tt></td>
-<td>Compare for equality with <tt class="literal"><span class="pre">j</span></tt></td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">i.increment()</span></tt></td>
-<td>Advance by one position</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">i.decrement()</span></tt></td>
-<td>Retreat by one position</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">i.advance(n)</span></tt></td>
-<td>Advance by <tt class="literal"><span class="pre">n</span></tt> positions</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">i.distance_to(j)</span></tt></td>
-<td>Measure the distance to <tt class="literal"><span class="pre">j</span></tt></td>
-</tr>
-</tbody>
-</table>
-</blockquote>
-<!-- Should we add a comment that a zero overhead implementation of iterator_facade
-is possible with proper inlining? -->
-<p>In addition to implementing the core interface functions, an iterator
-derived from <tt class="literal"><span class="pre">iterator_facade</span></tt> 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 <tt class="literal"><span class="pre">X</span></tt> is meant to be automatically interoperate with another
-iterator type <tt class="literal"><span class="pre">Y</span></tt> (as with constant and mutable iterators) then
-there must be an implicit conversion from <tt class="literal"><span class="pre">X</span></tt> to <tt class="literal"><span class="pre">Y</span></tt> or from <tt class="literal"><span class="pre">Y</span></tt>
-to <tt class="literal"><span class="pre">X</span></tt> (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.</p>
-</div>
-<div class="section" id="iterator-core-access">
-<h1><a class="toc-backref" href="#id9" name="iterator-core-access">Iterator Core Access</a></h1>
-<p><tt class="literal"><span class="pre">iterator_facade</span></tt> 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.</p>
-<p>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 <tt class="literal"><span class="pre">iterator_facade</span></tt> without fear of
-breaking code that was accessing the public core member functions
-directly.</p>
-<p>In a naive implementation, keeping the derived class' core member
-functions private would require it to grant friendship to
-<tt class="literal"><span class="pre">iterator_facade</span></tt> and each of the seven operators.  In order to
-reduce the burden of limiting access, <tt class="literal"><span class="pre">iterator_core_access</span></tt> 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 <tt class="literal"><span class="pre">iterator_core_access</span></tt> to make his core
-member functions available to the library.</p>
-<!-- This is no long uptodate -thw  -->
-<!-- Yes it is; I made sure of it! -DWA -->
-<p><tt class="literal"><span class="pre">iterator_core_access</span></tt> 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
-<tt class="literal"><span class="pre">iterator_core_access</span></tt> used public member functions it would not
-open a safety loophole, as every core member function preserves the
-invariants of the iterator.</p>
-</div>
-<div class="section" id="operator">
-<h1><a class="toc-backref" href="#id10" name="operator"><tt class="literal"><span class="pre">operator[]</span></tt></a></h1>
-<p>The indexing operator for a generalized iterator presents special
-challenges.  A random access iterator's <tt class="literal"><span class="pre">operator[]</span></tt> is only
-required to return something convertible to its <tt class="literal"><span class="pre">value_type</span></tt>.
-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. <a class="reference" href="counting_iterator.html"><tt class="literal"><span class="pre">counting_iterator</span></tt></a>), because <tt class="literal"><span class="pre">*(p+n)</span></tt> is a reference
-into the temporary iterator <tt class="literal"><span class="pre">p+n</span></tt>, which is destroyed when
-<tt class="literal"><span class="pre">operator[]</span></tt> returns.</p>
-<p>Writable iterators built with <tt class="literal"><span class="pre">iterator_facade</span></tt> implement the
-semantics required by the preferred resolution to <a class="reference" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#299">issue 299</a> and
-adopted by proposal <a class="reference" href="http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html">n1550</a>: the result of <tt class="literal"><span class="pre">p[n]</span></tt> is a proxy object
-containing a copy of <tt class="literal"><span class="pre">p+n</span></tt>, and <tt class="literal"><span class="pre">p[n]</span> <span class="pre">=</span> <span class="pre">x</span></tt> is equivalent to <tt class="literal"><span class="pre">*(p</span>
-<span class="pre">+</span> <span class="pre">n)</span> <span class="pre">=</span> <span class="pre">x</span></tt>.  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 <tt class="literal"><span class="pre">operator[]</span></tt> which returns an lvalue in the derived
-iterator class; it will hide the one supplied by <tt class="literal"><span class="pre">iterator_facade</span></tt>
-from clients of her iterator.</p>
-<a class="target" id="operator-arrow" name="operator-arrow"></a></div>
-<div class="section" id="id2">
-<h1><a class="toc-backref" href="#id11" name="id2"><tt class="literal"><span class="pre">operator-&gt;</span></tt></a></h1>
-<p>The <tt class="literal"><span class="pre">reference</span></tt> 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 <tt class="literal"><span class="pre">value_type</span></tt>.  When the <tt class="literal"><span class="pre">value_type</span></tt>
-is a class, however, it must still be possible to access members
-through <tt class="literal"><span class="pre">operator-&gt;</span></tt>.  Therefore, an iterator whose <tt class="literal"><span class="pre">reference</span></tt>
-type is not in fact a reference must return a proxy containing a copy
-of the referenced value from its <tt class="literal"><span class="pre">operator-&gt;</span></tt>.</p>
-<p>The return type for <tt class="literal"><span class="pre">operator-&gt;</span></tt> and <tt class="literal"><span class="pre">operator[]</span></tt> is not
-explicitly specified. Instead it requires each <tt class="literal"><span class="pre">iterator_facade</span></tt>
-specialization to meet the requirements of its <tt class="literal"><span class="pre">iterator_category</span></tt>.</p>
-<table class="citation" frame="void" id="cop95" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<col />
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id1" 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>
-</div>
-<div class="section" id="reference">
-<h1><a class="toc-backref" href="#id12" name="reference">Reference</a></h1>
-<!-- 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 -->
-<pre class="literal-block">
-template &lt;
-    class Derived
-  , class Value
-  , class CategoryOrTraversal
-  , class Reference  = Value&amp;
-  , class Difference = ptrdiff_t
-&gt;
-class iterator_facade {
-public:
-    typedef remove_const&lt;Value&gt;::type value_type;
-    typedef Reference reference;
-    typedef Value* pointer;
-    typedef Difference difference_type;
-    typedef /* see <a class="reference" href="#facade-iterator-category">below</a> */ iterator_category;
-
-    reference operator*() const;
-    /* see <a class="reference" href="#operator-arrow">below</a> */ operator-&gt;() const;
-    /* see <a class="reference" href="#brackets">below</a> */ operator[](difference_type n) const;
-    Derived&amp; operator++();
-    Derived operator++(int);
-    Derived&amp; operator--();
-    Derived operator--(int);
-    Derived&amp; operator+=(difference_type n);
-    Derived&amp; operator-=(difference_type n);
-    Derived operator-(difference_type n) const;
-};
-
-// Comparison operators
-template &lt;class Dr1, class V1, class TC1, class R1, class D1,
-          class Dr2, class V2, class TC2, class R2, class D2&gt;
-typename enable_if_interoperable&lt;Dr1, Dr2, bool&gt;::type // exposition
-operator ==(iterator_facade&lt;Dr1, V1, TC1, R1, D1&gt; const&amp; lhs,
-            iterator_facade&lt;Dr2, V2, TC2, R2, D2&gt; const&amp; rhs);
-
-template &lt;class Dr1, class V1, class TC1, class R1, class D1,
-          class Dr2, class V2, class TC2, class R2, class D2&gt;
-typename enable_if_interoperable&lt;Dr1, Dr2, bool&gt;::type
-operator !=(iterator_facade&lt;Dr1, V1, TC1, R1, D1&gt; const&amp; lhs,
-            iterator_facade&lt;Dr2, V2, TC2, R2, D2&gt; const&amp; rhs);
-
-template &lt;class Dr1, class V1, class TC1, class R1, class D1,
-          class Dr2, class V2, class TC2, class R2, class D2&gt;
-typename enable_if_interoperable&lt;Dr1, Dr2, bool&gt;::type
-operator &lt;(iterator_facade&lt;Dr1, V1, TC1, R1, D1&gt; const&amp; lhs,
-           iterator_facade&lt;Dr2, V2, TC2, R2, D2&gt; const&amp; rhs);
-
-template &lt;class Dr1, class V1, class TC1, class R1, class D1,
-          class Dr2, class V2, class TC2, class R2, class D2&gt;
-typename enable_if_interoperable&lt;Dr1, Dr2, bool&gt;::type
-operator &lt;=(iterator_facade&lt;Dr1, V1, TC1, R1, D1&gt; const&amp; lhs,
-            iterator_facade&lt;Dr2, V2, TC2, R2, D2&gt; const&amp; rhs);
-
-template &lt;class Dr1, class V1, class TC1, class R1, class D1,
-          class Dr2, class V2, class TC2, class R2, class D2&gt;
-typename enable_if_interoperable&lt;Dr1, Dr2, bool&gt;::type
-operator &gt;(iterator_facade&lt;Dr1, V1, TC1, R1, D1&gt; const&amp; lhs,
-           iterator_facade&lt;Dr2, V2, TC2, R2, D2&gt; const&amp; rhs);
-
-template &lt;class Dr1, class V1, class TC1, class R1, class D1,
-          class Dr2, class V2, class TC2, class R2, class D2&gt;
-typename enable_if_interoperable&lt;Dr1, Dr2, bool&gt;::type
-operator &gt;=(iterator_facade&lt;Dr1, V1, TC1, R1, D1&gt; const&amp; lhs,
-            iterator_facade&lt;Dr2, V2, TC2, R2, D2&gt; const&amp; rhs);
-
-template &lt;class Dr1, class V1, class TC1, class R1, class D1,
-          class Dr2, class V2, class TC2, class R2, class D2&gt;
-typename enable_if_interoperable&lt;Dr1, Dr2, bool&gt;::type
-operator &gt;=(iterator_facade&lt;Dr1, V1, TC1, R1, D1&gt; const&amp; lhs,
-            iterator_facade&lt;Dr2, V2, TC2, R2, D2&gt; const&amp; rhs);
-
-// Iterator difference
-template &lt;class Dr1, class V1, class TC1, class R1, class D1,
-          class Dr2, class V2, class TC2, class R2, class D2&gt;
-typename enable_if_interoperable&lt;Dr1, Dr2, bool&gt;::type
-operator -(iterator_facade&lt;Dr1, V1, TC1, R1, D1&gt; const&amp; lhs,
-           iterator_facade&lt;Dr2, V2, TC2, R2, D2&gt; const&amp; rhs);
-
-// Iterator addition
-template &lt;class Derived, class V, class TC, class R, class D&gt;
-Derived operator+ (iterator_facade&lt;Derived, V, TC, R, D&gt; const&amp;,
-                   typename Derived::difference_type n)
-</pre>
-<p>The <tt class="literal"><span class="pre">enable_if_interoperable</span></tt> template used above is for exposition
-purposes.  The member operators should be only be in an overload set
-provided the derived types <tt class="literal"><span class="pre">Dr1</span></tt> and <tt class="literal"><span class="pre">Dr2</span></tt> are interoperable, 
-meaning that at least one of the types is convertible to the other.  The
-<tt class="literal"><span class="pre">enable_if_interoperable</span></tt> approach uses SFINAE to take the operators
-out of the overload set when the types are not interoperable.  
-The operators should behave <em>as-if</em> <tt class="literal"><span class="pre">enable_if_interoperable</span></tt>
-were defined to be:</p>
-<pre class="literal-block">
-template &lt;bool, typename&gt; enable_if_interoperable_impl
-{};
-
-template &lt;typename T&gt; enable_if_interoperable_impl&lt;true,T&gt;
-{ typedef T type; };
-
-template&lt;typename Dr1, typename Dr2, typename T&gt;
-struct enable_if_interoperable
-  : enable_if_interoperable_impl&lt;
-        is_convertible&lt;Dr1,Dr2&gt;::value || is_convertible&lt;Dr2,Dr1&gt;::value
-      , T
-    &gt;
-{};
-</pre>
-<div class="section" id="iterator-facade-usage">
-<h2><a class="toc-backref" href="#id13" name="iterator-facade-usage"><tt class="literal"><span class="pre">iterator_facade</span></tt> usage</a></h2>
-<p>The following table describes the typical valid expressions on
-<tt class="literal"><span class="pre">iterator_facade</span></tt>'s <tt class="literal"><span class="pre">Derived</span></tt> 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
-<tt class="literal"><span class="pre">iterator_core_access</span></tt>.</p>
-<p>In the table below, <tt class="literal"><span class="pre">F</span></tt> is <tt class="literal"><span class="pre">iterator_facade&lt;X,V,C,R,D&gt;</span></tt>, <tt class="literal"><span class="pre">a</span></tt> is an
-object of type <tt class="literal"><span class="pre">X</span></tt>, <tt class="literal"><span class="pre">b</span></tt> and <tt class="literal"><span class="pre">c</span></tt> are objects of type <tt class="literal"><span class="pre">const</span> <span class="pre">X</span></tt>,
-<tt class="literal"><span class="pre">n</span></tt> is an object of <tt class="literal"><span class="pre">F::difference_type</span></tt>, <tt class="literal"><span class="pre">y</span></tt> is a constant
-object of a single pass iterator type interoperable with <tt class="literal"><span class="pre">X</span></tt>, and <tt class="literal"><span class="pre">z</span></tt>
-is a constant object of a random access traversal iterator type
-interoperable with <tt class="literal"><span class="pre">X</span></tt>.</p>
-<table border class="table">
-<colgroup>
-<col width="19%" />
-<col width="21%" />
-<col width="35%" />
-<col width="25%" />
-</colgroup>
-<thead valign="bottom">
-<tr><th>Expression</th>
-<th>Return Type</th>
-<th>Assertion/Note</th>
-<th>Used to implement Iterator
-Concept(s)</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr><td><tt class="literal"><span class="pre">c.dereference()</span></tt></td>
-<td><tt class="literal"><span class="pre">F::reference</span></tt></td>
-<td>&nbsp;</td>
-<td>Readable Iterator, Writable
-Iterator</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">c.equal(b)</span></tt></td>
-<td>convertible to bool</td>
-<td>true iff <tt class="literal"><span class="pre">b</span></tt> and <tt class="literal"><span class="pre">c</span></tt> are
-equivalent.</td>
-<td>Single Pass Iterator</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">c.equal(y)</span></tt></td>
-<td>convertible to bool</td>
-<td>true iff <tt class="literal"><span class="pre">c</span></tt> and <tt class="literal"><span class="pre">y</span></tt> refer to the
-same position.  Implements <tt class="literal"><span class="pre">c</span> <span class="pre">==</span> <span class="pre">y</span></tt>
-and <tt class="literal"><span class="pre">c</span> <span class="pre">!=</span> <span class="pre">y</span></tt>.</td>
-<td>Single Pass Iterator</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">a.advance(n)</span></tt></td>
-<td>unused</td>
-<td>&nbsp;</td>
-<td>Random Access Traversal
-Iterator</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">a.increment()</span></tt></td>
-<td>unused</td>
-<td>&nbsp;</td>
-<td>Incrementable Iterator</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">a.decrement()</span></tt></td>
-<td>unused</td>
-<td>&nbsp;</td>
-<td>Bidirectional Traversal
-Iterator</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">c.distance_to(b)</span></tt></td>
-<td>convertible to
-<tt class="literal"><span class="pre">F::difference_type</span></tt></td>
-<td>equivalent to <tt class="literal"><span class="pre">distance(c,</span> <span class="pre">b)</span></tt></td>
-<td>Random Access Traversal
-Iterator</td>
-</tr>
-<tr><td><tt class="literal"><span class="pre">c.distance_to(z)</span></tt></td>
-<td>convertible to
-<tt class="literal"><span class="pre">F::difference_type</span></tt></td>
-<td>equivalent to <tt class="literal"><span class="pre">distance(c,</span> <span class="pre">z)</span></tt>.
-Implements <tt class="literal"><span class="pre">c</span> <span class="pre">-</span> <span class="pre">z</span></tt>, <tt class="literal"><span class="pre">c</span> <span class="pre">&lt;</span> <span class="pre">z</span></tt>, <tt class="literal"><span class="pre">c</span>
-<span class="pre">&lt;=</span> <span class="pre">z</span></tt>, <tt class="literal"><span class="pre">c</span> <span class="pre">&gt;</span> <span class="pre">z</span></tt>, and <tt class="literal"><span class="pre">c</span> <span class="pre">&gt;=</span> <span class="pre">c</span></tt>.</td>
-<td>Random Access Traversal
-Iterator</td>
-</tr>
-</tbody>
-</table>
-<a class="target" id="facade-iterator-category" name="facade-iterator-category"></a></div>
-<div class="section" id="iterator-facade-iterator-category">
-<h2><a class="toc-backref" href="#id14" name="iterator-facade-iterator-category"><tt class="literal"><span class="pre">iterator_facade</span></tt> iterator category</a></h2>
-<p>The <tt class="literal"><span class="pre">iterator_category</span></tt> member of <tt class="literal"><span class="pre">iterator_facade&lt;X,V,R,C,D&gt;</span></tt>
-is a type which satisfies the following conditions:</p>
-<blockquote>
-<ul>
-<li><p class="first">if <tt class="literal"><span class="pre">C</span></tt> is convertible to <tt class="literal"><span class="pre">std::input_iterator_tag</span></tt> or
-<tt class="literal"><span class="pre">C</span></tt> is convertible to <tt class="literal"><span class="pre">std::output_iterator_tag</span></tt>,
-<tt class="literal"><span class="pre">iterator_category</span></tt> is the same as <tt class="literal"><span class="pre">C</span></tt>.</p>
-</li>
-<li><p class="first">Otherwise, if <tt class="literal"><span class="pre">C</span></tt> is not convertible to
-<tt class="literal"><span class="pre">incrementable_traversal_tag</span></tt>, the program is ill-formed</p>
-</li>
-<li><p class="first">Otherwise:</p>
-<ul>
-<li><p class="first"><tt class="literal"><span class="pre">iterator_category</span></tt> is convertible to the iterator
-category tag or tags given by the following algorithm, and
-not to any more-derived iterator category tag or tags:</p>
-<pre class="literal-block">
-if (R is a reference type
-    &amp;&amp; C is convertible to forward_traversal_tag)
-{
-    if (C is convertible to random_access_traversal_tag)
-        return random_access_iterator_tag
-    else if (C is convertible to bidirectional_traversal_tag)
-        return bidirectional_iterator_tag
-    else
-        return forward_traversal_tag
-}
-else
-{
-    if (C is convertible to single_pass_traversal_tag
-        &amp;&amp; R is convertible to V)
-    {
-        if (V is const)
-            return input_iterator_tag
-        else
-            return input_iterator_tag and output_iterator_tag
-    }
-    else
-        return output_iterator_tag
-}
-</pre>
-</li>
-<li><p class="first"><tt class="literal"><span class="pre">iterator_traversal&lt;X&gt;::type</span></tt> is convertible to the most
-derived traversal tag type to which <tt class="literal"><span class="pre">C</span></tt> is also
-convertible, and not to any more-derived traversal tag type.</p>
-</li>
-</ul>
-</li>
-</ul>
-</blockquote>
-</div>
-<div class="section" id="iterator-facade-operations">
-<h2><a class="toc-backref" href="#id15" name="iterator-facade-operations"><tt class="literal"><span class="pre">iterator_facade</span></tt> operations</a></h2>
-<p>The operations in this section are described in terms of operations on
-the core interface of <tt class="literal"><span class="pre">Derived</span></tt> which may be inaccessible
-(i.e. private).  The implementation should access these operations
-through member functions of class <tt class="literal"><span class="pre">iterator_core_access</span></tt>.</p>
-<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">static_cast&lt;Derived</span> <span class="pre">const*&gt;(this)-&gt;dereference()</span></tt></td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">operator-&gt;()</span> <span class="pre">const;</span></tt> (see <a class="reference" href="#operator-arrow">below</a>)</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"><p class="first">If <tt class="literal"><span class="pre">reference</span></tt> is a reference type, an object
-of type <tt class="literal"><span class="pre">pointer</span></tt> equal to:</p>
-<pre class="literal-block">
-&amp;static_cast&lt;Derived const*&gt;(this)-&gt;dereference()
-</pre>
-<p class="last">Otherwise returns an object of unspecified type such that, 
-<tt class="literal"><span class="pre">(*static_cast&lt;Derived</span> <span class="pre">const*&gt;(this))-&gt;m</span></tt> is equivalent to <tt class="literal"><span class="pre">(w</span> <span class="pre">=</span> <span class="pre">**static_cast&lt;Derived</span> <span class="pre">const*&gt;(this),</span>
-<span class="pre">w.m)</span></tt> for some temporary object <tt class="literal"><span class="pre">w</span></tt> of type <tt class="literal"><span class="pre">value_type</span></tt>.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<a class="target" id="brackets" name="brackets"></a><p><em>unspecified</em> <tt class="literal"><span class="pre">operator[](difference_type</span> <span class="pre">n)</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">an object convertible to <tt class="literal"><span class="pre">reference</span></tt> and holding a copy
-<em>p</em> of <tt class="literal"><span class="pre">*static_cast&lt;Derived</span> <span class="pre">const*&gt;(this)</span> <span class="pre">+</span> <span class="pre">n</span></tt> such that, for a constant object <tt class="literal"><span class="pre">v</span></tt> of type
-<tt class="literal"><span class="pre">value_type</span></tt>, <tt class="literal"><span class="pre">(*static_cast&lt;Derived</span> <span class="pre">const*&gt;(this))[n]</span> <span class="pre">=</span> <span class="pre">v</span></tt> is equivalent
-to <tt class="literal"><span class="pre">p</span> <span class="pre">=</span> <span class="pre">v</span></tt>.</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">Derived&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"><pre class="first last literal-block">
-static_cast&lt;Derived*&gt;(this)-&gt;increment();
-return *static_cast&lt;Derived*&gt;(this);
-</pre>
-</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">Derived</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">Effects:</th><td class="field-body"><pre class="first last literal-block">
-Derived tmp(static_cast&lt;Derived const*&gt;(this));
-++*this;
-return tmp;
-</pre>
-</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">Derived&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"><pre class="first last literal-block">
-static_cast&lt;Derived*&gt;(this)-&gt;decrement();
-return static_cast&lt;Derived*&gt;(this);
-</pre>
-</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">Derived</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">Effects:</th><td class="field-body"><pre class="first last literal-block">
-Derived tmp(static_cast&lt;Derived const*&gt;(this));
---*this;
-return tmp;
-</pre>
-</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">Derived&amp;</span> <span class="pre">operator+=(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"><pre class="first last literal-block">
-static_cast&lt;Derived*&gt;(this)-&gt;advance(n);
-return static_cast&lt;Derived*&gt;(this);
-</pre>
-</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">Derived&amp;</span> <span class="pre">operator-=(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"><pre class="first last literal-block">
-static_cast&lt;Derived*&gt;(this)-&gt;advance(-n);
-return static_cast&lt;Derived*&gt;(this);
-</pre>
-</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">Derived</span> <span class="pre">operator-(difference_type</span> <span class="pre">n)</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">Effects:</th><td class="field-body"><pre class="first last literal-block">
-Derived tmp(static_cast&lt;Derived const*&gt;(this));
-return tmp -= n;
-</pre>
-</td>
-</tr>
-</tbody>
-</table>
-</div>
-</div>
-</div>
-<hr class="footer" />
-<div class="footer">
-<a class="reference" href="iterator_facade.rst">View document source</a>.
-Generated on: 2003-11-24 05:00 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_facade.rst

@@ -1,35 +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
-
-
-Motivation
-----------
-
-.. include:: iterator_facade_body.rst
-
-
-Reference
----------
-
-.. include:: iterator_facade_ref.rst
-
-.. _counting: counting_iterator.html

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,187 +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.  ``iterator_facade`` does not use policy
-objects 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 means
-     that all iterators generated by ``iterator_facade`` would be
-     specializations of ``iterator_facade``.  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 an
-specialization of ``iterator_facade`` which takes the derived iterator
-class as the first template parameter.  The order of the other
-template parameters to ``iterator_facade`` 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 a proxy object
-containing a copy of ``p+n``, and ``p[n] = x`` is equivalent to ``*(p
-+ n) = x``.  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[]`` which 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 type for ``operator->`` and ``operator[]`` is not
-explicitly specified. Instead it requires each ``iterator_facade``
-specialization to meet the requirements of its ``iterator_category``.
-
-
-.. [Cop95] [Coplien, 1995] Coplien, J., Curiously Recurring Template
-   Patterns, C++ Report, February 1995, pp. 24-27.
-

doc/iterator_facade_ref.rst

@@ -1,326 +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;
-  };
-
-  // 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);
-
-  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>
-  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 addition
-  template <class Derived, class V, class TC, class R, class D>
-  Derived operator+ (iterator_facade<Derived, V, TC, R, D> const&,
-                     typename Derived::difference_type n)
-
-
-__ `facade iterator category`_
-
-__ `operator arrow`_
-
-__ brackets_
-
-The ``enable_if_interoperable`` template used above is for exposition
-purposes.  The member operators should be 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`` usage
-.........................
-
-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 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``.
-
-+--------------------+----------------------+-------------------------------------+---------------------------+
-|Expression          |Return Type           |Assertion/Note                       |Used to implement Iterator |
-|                    |                      |                                     |Concept(s)                 |
-+====================+======================+=====================================+===========================+
-|``c.dereference()`` |``F::reference``      |                                     |Readable Iterator, Writable|
-|                    |                      |                                     |Iterator                   |
-+--------------------+----------------------+-------------------------------------+---------------------------+
-|``c.equal(b)``      |convertible to bool   |true iff ``b`` and ``c`` are         |Single Pass Iterator       |
-|                    |                      |equivalent.                          |                           |
-+--------------------+----------------------+-------------------------------------+---------------------------+
-|``c.equal(y)``      |convertible to bool   |true iff ``c`` and ``y`` refer to the|Single Pass Iterator       |
-|                    |                      |same position.  Implements ``c == y``|                           |
-|                    |                      |and ``c != y``.                      |                           |
-+--------------------+----------------------+-------------------------------------+---------------------------+
-|``a.advance(n)``    |unused                |                                     |Random Access Traversal    |
-|                    |                      |                                     |Iterator                   |
-+--------------------+----------------------+-------------------------------------+---------------------------+
-|``a.increment()``   |unused                |                                     |Incrementable Iterator     |
-+--------------------+----------------------+-------------------------------------+---------------------------+
-|``a.decrement()``   |unused                |                                     |Bidirectional Traversal    |
-|                    |                      |                                     |Iterator                   |
-+--------------------+----------------------+-------------------------------------+---------------------------+
-|``c.distance_to(b)``|convertible to        |equivalent to ``distance(c, b)``     |Random Access Traversal    |
-|                    |``F::difference_type``|                                     |Iterator                   |
-+--------------------+----------------------+-------------------------------------+---------------------------+
-|``c.distance_to(z)``|convertible to        |equivalent to ``distance(c, z)``.    |Random Access Traversal    |
-|                    |``F::difference_type``|Implements ``c - z``, ``c < z``, ``c |Iterator                   |
-|                    |                      |<= z``, ``c > z``, and ``c >= c``.   |                           |
-+--------------------+----------------------+-------------------------------------+---------------------------+
-
-.. _facade iterator category:
-
-``iterator_facade`` iterator category
-.....................................
-
-The ``iterator_category`` member of ``iterator_facade<X,V,R,C,D>``
-is a type which satisfies the following conditions:
-
-   * if ``C`` is convertible to ``std::input_iterator_tag`` or
-     ``C`` is convertible to ``std::output_iterator_tag``,
-     ``iterator_category`` is the same as ``C``.  
-
-   * Otherwise, if ``C`` is not convertible to
-     ``incrementable_traversal_tag``, the program is ill-formed 
-
-   * Otherwise:
-
-     - ``iterator_category`` is convertible to the iterator
-       category tag or tags given by the following algorithm, and
-       not to any more-derived iterator category tag or tags::
-
-         if (R is a reference type
-             && C is convertible to forward_traversal_tag)
-         {
-             if (C is convertible to random_access_traversal_tag)
-                 return random_access_iterator_tag
-             else if (C is convertible to bidirectional_traversal_tag)
-                 return bidirectional_iterator_tag
-             else
-                 return forward_traversal_tag
-         }
-         else
-         {
-             if (C is convertible to single_pass_traversal_tag
-                 && R is convertible to V)
-             {
-                 if (V is const)
-                     return input_iterator_tag
-                 else
-                     return input_iterator_tag and output_iterator_tag
-             }
-             else
-                 return output_iterator_tag
-         }
-
-     - ``iterator_traversal<X>::type`` is convertible to the most
-       derived traversal tag type to which ``C`` is also
-       convertible, and not to any more-derived traversal tag type.
-
-
-``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 ``reference`` and holding a copy
-     *p* of ``*static_cast<Derived const*>(this) + n`` such that, for a constant object ``v`` of type
-     ``value_type``, ``(*static_cast<Derived const*>(this))[n] = v`` is equivalent
-     to ``p = v``.
-
-
-
-``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;
-
-
-

doc/new-iter-concepts.rst

@@ -1,730 +0,0 @@
-++++++++++++++++++++++
- New Iterator Concepts
-++++++++++++++++++++++
-
-.. Version 1.25 of this ReStructuredText document is the same as
-   n1550_, the paper accepted by the LWG.
-
-:Author: David Abrahams, Jeremy Siek, Thomas Witt
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@acm.org
-:organization: `Boost Consulting`_, Indiana University `Open
-               Systems Lab`_, University of Hanover `Institute for
-               Transport Railway Operation and Construction`_
-:date: $Date$
-
-:Number: This is a revised version of n1550_\ =03-0133, which was
-         accepted for Technical Report 1 by the C++ standard
-         committee's library working group. This proposal is a
-         revision of paper n1297_, n1477_, and n1531_.
-
-: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: We propose a new system of iterator concepts that treat
-           access and positioning independently. This allows the
-           concepts to more closely match the requirements
-           of algorithms and provides better categorizations
-           of iterators that are used in practice. 
-          
-.. contents:: Table of Contents
-
-.. _n1297: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2001/n1297.html
-.. _n1477: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1477.html
-.. _n1531: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1531.html
-.. _n1550: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1550.html
-
-============
- Motivation
-============
-
-The standard iterator categories and requirements are flawed because
-they use a single hierarchy of concepts to address two orthogonal
-issues: *iterator traversal* and *value access*. As a result, many
-algorithms with requirements expressed in terms of the iterator
-categories are too strict. Also, many real-world iterators can not be
-accurately categorized.  A proxy-based iterator with random-access
-traversal, for example, may only legally have a category of "input
-iterator", so generic algorithms are unable to take advantage of its
-random-access capabilities.  The current iterator concept hierarchy is
-geared towards iterator traversal (hence the category names), while
-requirements that address value access sneak in at various places. The
-following table gives a summary of the current value access
-requirements in the iterator categories.
-
-+------------------------------------------------------------------------------+
-|Value Access Requirements in Existing Iterator Categories                     |
-+========================+=====================================================+
-|Output Iterator         |``*i = a``                                           |
-+------------------------+-----------------------------------------------------+
-|Input Iterator          |``*i`` is convertible to ``T``                       |
-+------------------------+-----------------------------------------------------+
-|Forward Iterator        |``*i`` is ``T&`` (or ``const T&`` once `issue 200`_  |
-|                        |is resolved)                                         |
-+------------------------+-----------------------------------------------------+
-|Random Access Iterator  |``i[n]`` is convertible to ``T`` (also ``i[n] = t``  |
-|                        |is required for mutable iterators once `issue 299`_  |
-|                        |is resolved)                                         |
-+------------------------+-----------------------------------------------------+
-
-.. _issue 200: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#200
-.. _issue 299: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#299
-
-
-Because iterator traversal and value access are mixed together in a
-single hierarchy, many useful iterators can not be appropriately
-categorized. For example, ``vector<bool>::iterator`` is almost a
-random access iterator, but the return type is not ``bool&`` (see
-`issue 96`_ and Herb Sutter's paper J16/99-0008 = WG21
-N1185). Therefore, the iterators of ``vector<bool>`` only meet the
-requirements of input iterator and output iterator.  This is so
-nonintuitive that the C++ standard contradicts itself on this point.
-In paragraph 23.2.4/1 it says that a ``vector`` is a sequence that
-supports random access iterators.
-
-.. _issue 96: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/lwg-active.html#96
-
-Another difficult-to-categorize iterator is the transform iterator, an
-adaptor which applies a unary function object to the dereferenced
-value of the some underlying iterator (see `transform_iterator`_).
-For unary functions such as ``times``, the return type of
-``operator*`` clearly needs to be the ``result_type`` of the function
-object, which is typically not a reference.  Because random access
-iterators are required to return lvalues from ``operator*``, if you
-wrap ``int*`` with a transform iterator, you do not get a random
-access iterator as might be expected, but an input iterator.
-
-.. _`transform_iterator`: http://www.boost.org/libs/utility/transform_iterator.htm
-
-A third example is found in the vertex and edge iterators of the
-`Boost Graph Library`_. These iterators return vertex and edge
-descriptors, which are lightweight handles created on-the-fly. They
-must be returned by-value. As a result, their current standard
-iterator category is ``input_iterator_tag``, which means that,
-strictly speaking, you could not use these iterators with algorithms
-like ``min_element()``. As a temporary solution, the concept
-`Multi-Pass Input Iterator`_ was introduced to describe the vertex and
-edge descriptors, but as the design notes for the concept suggest, a
-better solution is needed.
-
-.. _Boost Graph Library: http://www.boost.org/libs/graph/doc/table_of_contents.html
-.. _Multi-Pass Input Iterator: http://www.boost.org/libs/utility/MultiPassInputIterator.html
-
-In short, there are many useful iterators that do not fit into the
-current standard iterator categories. As a result, the following bad
-things happen:
-
-- Iterators are often mis-categorized. 
-
-- Algorithm requirements are more strict than necessary, because they
-  cannot separate the need for random access or bidirectional
-  traversal from the need for a true reference return type.
-
-
-========================
- Impact on the Standard
-========================
-
-This proposal for TR1 is a pure extension. Further, the new iterator
-concepts are backward-compatible with the old iterator requirements,
-and old iterators are forward-compatible with the new iterator
-concepts. That is to say, iterators that satisfy the old requirements
-also satisfy appropriate concepts in the new system, and iterators
-modeling the new concepts will automatically satisfy the appropriate
-old requirements.
-
-.. I think we need to say something about the resolution to allow
-   convertibility to any of the old-style tags as a TR issue (hope it
-   made it). -DWA
-
-.. Hmm, not sure I understand. Are you talking about whether a
-   standards conforming input iterator is allowed to have
-   a tag that is not input_iterator_tag but that
-   is convertible to input_iterator_tag? -JGS
-
-Note that as currently specified, ``istreambuf_iterator`` doesn't
-meet the Readable Iterator requirements because its ``value_type``
-is not convertible to its ``reference`` type.  We believe this to
-be a defect in the standard; it should be fixed by changing its
-``reference`` type from ``value_type&`` to ``value_type const&``.
-
-Possible (but not proposed) Changes to the Working Paper
-========================================================
-
-The extensions in this paper suggest several changes we might make
-to the working paper for the next standard.  These changes are not
-a formal part of this proposal for TR1.
-
-Changes to Algorithm Requirements
-+++++++++++++++++++++++++++++++++
-
-The algorithms in the standard library could benefit from the new
-iterator concepts because the new concepts provide a more accurate way
-to express their type requirements. The result is algorithms that are
-usable in more situations and have fewer type requirements.
-
-For the next working paper (but not for TR1), the committee should
-consider the following changes to the type requirements of
-algorithms.  These changes are phrased as phrased as textual
-substitutions, listing the algorithms to which each textual
-substitution applies.
-
-Forward Iterator -> Forward Traversal Iterator and Readable Iterator
-
-  ``find_end, adjacent_find, search, search_n, rotate_copy,
-  lower_bound, upper_bound, equal_range, binary_search,
-  min_element, max_element``
-
-Forward Iterator (1) -> Single Pass Iterator and Readable Iterator,
-Forward Iterator (2) -> Forward Traversal Iterator and Readable Iterator
-
-  ``find_first_of``
-
-Forward Iterator -> Readable Iterator and Writable Iterator
-
-  ``iter_swap``
-
-Forward Iterator -> Single Pass Iterator and Writable Iterator
-
-  ``fill, generate``
-
-Forward Iterator -> Forward Traversal Iterator and Swappable Iterator
-
-  ``rotate``
-
-Forward Iterator (1) -> Swappable Iterator and Single Pass Iterator,
-Forward Iterator (2) -> Swappable Iterator and  Incrementable Iterator
-
-  ``swap_ranges``
-
-Forward Iterator -> Forward Traversal Iterator and Readable Iterator and Writable Iterator
-  ``remove, remove_if, unique``
-
-Forward Iterator -> Single Pass Iterator and Readable Iterator and Writable Iterator
-
-  ``replace, replace_if``
-
-Bidirectional Iterator -> Bidirectional Traversal Iterator and Swappable Iterator
-  ``reverse``
-
-Bidirectional Iterator -> Bidirectional Traversal Iterator and Readable and Swappable Iterator
-  ``partition``
-
-Bidirectional Iterator (1) -> Bidirectional Traversal Iterator and Readable Iterator, 
-Bidirectional Iterator (2) -> Bidirectional Traversal Iterator and Writable Iterator
-
-  ``copy_backwards``
-
-Bidirectional Iterator -> Bidirectional Traversal Iterator and Swappable Iterator and Readable Iterator
-  ``next_permutation, prev_permutation``
-
-Bidirectional Iterator -> Bidirectional Traversal Iterator and Readable Iterator and Writable Iterator
-  ``stable_partition, inplace_merge``
-
-Bidirectional Iterator -> Bidirectional Traversal Iterator and Readable Iterator
-  ``reverse_copy``
-
-Random Access Iterator -> Random Access Traversal Iterator and Readable and Writable Iterator
-  ``random_shuffle, sort, stable_sort, partial_sort, nth_element, push_heap, pop_heap
-  make_heap, sort_heap``
-
-Input Iterator (2) -> Incrementable Iterator and Readable Iterator
-  ``equal, mismatch``
-
-Input Iterator (2) -> Incrementable Iterator and Readable Iterator
-  ``transform``
-
-Deprecations
-++++++++++++
-
-For the next working paper (but not for TR1), the committee should
-consider deprecating the old iterator tags, and
-std::iterator_traits, since it will be superceded by individual
-traits metafunctions.
-
-``vector<bool>``
-++++++++++++++++
-
-For the next working paper (but not for TR1), the committee should
-consider reclassifying ``vector<bool>::iterator`` as a Random
-Access Traversal Iterator and Readable Iterator and Writable
-Iterator.
-
-========
- Design
-========
-
-The iterator requirements are to be separated into two groups. One set
-of concepts handles the syntax and semantics of value access:
-
-- Readable Iterator
-- Writable Iterator
-- Swappable Iterator
-- Lvalue Iterator
-
-The access concepts describe requirements related to ``operator*`` and
-``operator->``, including the ``value_type``, ``reference``, and
-``pointer`` associated types.
-
-The other set of concepts handles traversal:
-
-- Incrementable Iterator
-- Single Pass Iterator
-- Forward Traversal Iterator
-- Bidirectional Traversal Iterator
-- Random Access Traversal Iterator
-
-The refinement relationships for the traversal concepts are in the
-following diagram.
-
-.. image:: traversal.png
-
-In addition to the iterator movement operators, such as
-``operator++``, the traversal concepts also include requirements on
-position comparison such as ``operator==`` and ``operator<``.  The
-reason for the fine grain slicing of the concepts into the
-Incrementable and Single Pass is to provide concepts that are exact
-matches with the original input and output iterator requirements.
-
-The relationship between the new iterator concepts and the old are
-given in the following diagram.
-
-.. image:: oldeqnew.png
-
-Like the old iterator requirements, we provide tags for purposes of
-dispatching based on the traversal concepts.  The tags are related via
-inheritance so that a tag is convertible to another tag if the concept
-associated with the first tag is a refinement of the second tag.
-
-Our design reuses ``iterator_traits<Iter>::iterator_category`` to
-indicate an iterator's traversal capability.  To specify
-capabilities not captured by any old-style iterator category, an
-iterator designer can use an ``iterator_category`` type that is
-convertible to both the the most-derived old iterator category tag
-which fits, and the appropriate new iterator traversal tag.
-
-.. dwa2003/1/2: Note that we are not *requiring* convertibility to
-   a new-style traversal tag in order to meet new concepts.
-   Old-style iterators still fit, after all.
-
-We do not provide tags for the purposes of dispatching based on the
-access concepts, in part because we could not find a way to
-automatically infer the right access tags for old-style iterators.
-An iterator's writability may be dependent on the assignability of
-its ``value_type`` and there's no known way to detect whether an
-arbitrary type is assignable.  Fortunately, the need for
-dispatching based on access capability is not as great as the need
-for dispatching based on traversal capability.
-
-A difficult design decision concerned the ``operator[]``. The direct
-approach for specifying ``operator[]`` would have a return type of
-``reference``; the same as ``operator*``. However, going in this
-direction would mean that an iterator satisfying the old Random Access
-Iterator requirements would not necessarily be a model of Readable or
-Writable Lvalue Iterator.  Instead we have chosen a design that
-matches the preferred resolution of `issue 299`_: ``operator[]`` is
-only required to return something convertible to the ``value_type``
-(for a Readable Iterator), and is required to support assignment
-``i[n] = t`` (for a Writable Iterator).
-
-
-===============
- Proposed Text
-===============
-
-Addition to [lib.iterator.requirements]
-=======================================
-
-Iterator Value Access Concepts [lib.iterator.value.access]
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-In the tables below, ``X`` is an iterator type, ``a`` is a constant
-object of type ``X``, ``R`` is
-``std::iterator_traits<X>::reference``, ``T`` is
-``std::iterator_traits<X>::value_type``, and ``v`` is a constant
-object of type ``T``.
-
-.. _Readable Iterator:
-
-Readable Iterators [lib.readable.iterators]
--------------------------------------------
-
-A class or built-in type ``X`` models the *Readable Iterator* concept
-for the value type ``T`` if 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 CopyConstructible)                     |
-+-----------------------------------+------------------------+-------------------------+
-|Expression                         |Return Type             |Note/Precondition        |
-+===================================+========================+=========================+
-|``iterator_traits<X>::value_type`` |``T``                   |Any non-reference,       |
-|                                   |                        |non-cv-qualified type    |
-+-----------------------------------+------------------------+-------------------------+
-|``iterator_traits<X>::reference``  |``R``, Convertible to   |                         |
-|                                   |``T``                   |                         |
-+-----------------------------------+------------------------+-------------------------+
-|``*a``                             |Convertible to ``R``,   |pre: ``a`` is            |
-|                                   |Convertible to ``T``    |dereferenceable. If ``a  |
-|                                   |                        |== b`` then ``*a`` is    |
-|                                   |                        |equivalent to ``*b``     |
-+-----------------------------------+------------------------+-------------------------+
-|``static_cast<T>(                  |``T``                   |equivalent to            |
-|static_cast<R>(*a) )``             |                        |``static_cast<T>(*a)``   |
-+-----------------------------------+------------------------+-------------------------+
-|``a->m``                           |``U&``                  |pre: ``(*a).m`` is       |
-|                                   |                        |well-defined.  Equivalent|
-|                                   |                        |to ``(*a).m``            |
-+-----------------------------------+------------------------+-------------------------+
-
-.. TR1: the originally-proposed requirement that typeof(*a) == R
-   was too restrictive.  Now we just require that it's
-   convertible to R and that accessing a T through that conversion
-   is equivalent to accessing a T directly.
-
-.. _Writable Iterator:
-
-Writable Iterators [lib.writable.iterators]
--------------------------------------------
-
-A class or built-in type ``X`` models the *Writable Iterator* concept
-if 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 CopyConstructible)    |
-+-------------------------+--------------+----------------------------+
-|Expression               |Return Type   |Precondition                |
-+=========================+==============+============================+
-|``*a = o``               |              | pre: The type of ``o``     |
-|                         |              | is in the set of           |
-|                         |              | value types of ``X``       |
-+-------------------------+--------------+----------------------------+
-
-Swappable Iterators [lib.swappable.iterators]
----------------------------------------------
-
-A class or built-in type ``X`` models the *Swappable Iterator* concept
-if the following expressions are valid and respect the stated
-semantics.
-
-+---------------------------------------------------------------------+
-|Swappable Iterator Requirements (in addition to CopyConstructible)   |
-+-------------------------+-------------+-----------------------------+
-|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*]
-
-
-Lvalue Iterators [lib.lvalue.iterators]
----------------------------------------
-
-The *Lvalue Iterator* concept adds the requirement that the
-``reference`` type be a reference to the value type of the iterator.
-
-+---------------------------------------------------------------------------------+
-| Lvalue Iterator Requirements                                                    |
-+---------------------------------+-----------+-----------------------------------+
-|Expression                       |Return Type|Assertion                          |
-+=================================+===========+===================================+
-|``iterator_traits<X>::reference``|``T&``     |``T`` is *cv*                      |
-|                                 |           |``iterator_traits<X>::value_type`` |
-|                                 |           |where *cv* is an optional          |
-|                                 |           |cv-qualification                   |
-+---------------------------------+-----------+-----------------------------------+
-
-
-Iterator Traversal Concepts [lib.iterator.traversal]
-++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-In the tables below, ``X`` is an iterator type, ``a`` and ``b`` are
-constant objects of type ``X``, ``r`` and ``s`` are mutable objects of
-type ``X``, ``T`` is ``std::iterator_traits<X>::value_type``, and
-``v`` is a constant object of type ``T``.
-
-
-Incrementable Iterators [lib.incrementable.iterators]
------------------------------------------------------
-
-A class or built-in type ``X`` models the *Incrementable Iterator*
-concept if 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;     |
-|                                |                               | }                  |
-+--------------------------------+-------------------------------+--------------------+
-|``traversal_category<X>::type`` |Convertible to                 |                    |
-|                                |``incrementable_traversal_tag``|                    |
-+--------------------------------+-------------------------------+--------------------+
-
-.. TR1: incrementable_iterator_tag changed to
-   incrementable_traversal_tag for consistency.
-
-Single Pass Iterators [lib.single.pass.iterators]
--------------------------------------------------
-
-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)``              |
-+--------------------------------+-----------------------------+---------------------------+
-|``traversal_category<X>::type`` |Convertible to               |                           |
-|                                |``single_pass_traversal_tag``|                           |
-+--------------------------------+-----------------------------+---------------------------+
-
-.. TR1: single_pass_iterator_tag changed to
-   single_pass_traversal_tag for consistency
-
-
-Forward Traversal Iterators [lib.forward.traversal.iterators]
--------------------------------------------------------------
-
-A class or built-in type ``X`` models the *Forward Traversal Iterator*
-concept if the following expressions are valid and respect the stated
-semantics.
-
-+-------------------------------------------------------------------------------------------+
-|Forward Traversal Iterator Requirements (in addition to 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     |               |
-|                                       |                                   |               |
-+---------------------------------------+-----------------------------------+---------------+
-|``traversal_category<X>::type``        |Convertible to                     |               |
-|                                       |``forward_traversal_tag``          |               |
-+---------------------------------------+-----------------------------------+---------------+
-
-.. TR1: forward_traversal_iterator_tag changed to
-   forward_traversal_tag for consistency
-
-
-Bidirectional Traversal Iterators [lib.bidirectional.traversal.iterators]
--------------------------------------------------------------------------
-
-A class or built-in type ``X`` models the *Bidirectional Traversal
-Iterator* concept if 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;       |
-|                                    |                                             | }                   |
-+------------------------------------+---------------------------------------------+---------------------+
-|``traversal_category<X>::type``     |Convertible to                               |                     |
-|                                    |``bidirectional_traversal_tag``              |                     |
-|                                    |                                             |                     |
-+------------------------------------+---------------------------------------------+---------------------+
-
-.. TR1: bidirectional_traversal_iterator_tag changed to
-   bidirectional_traversal_tag for consistency
-
-Random Access Traversal Iterators [lib.random.access.traversal.iterators]
--------------------------------------------------------------------------
-
-A class or built-in type ``X`` models the *Random Access Traversal
-Iterator* 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 Iterator)                                               |
-+-------------------------------------------+-------------------------------------------------+-------------------------+----------------------+
-|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)``             |                      |
-+-------------------------------------------+-------------------------------------------------+-------------------------+----------------------+
-|``traversal_category<X>::type``            |Convertible to                                   |                         |                      |
-|                                           |``random_access_traversal_tag``                  |                         |                      |
-+-------------------------------------------+-------------------------------------------------+-------------------------+----------------------+
-
-.. TR1: random_access_traversal_iterator_tag changed to
-   random_access_traversal_tag for consistency
-
-
-Addition to [lib.iterator.synopsis]
-===================================
-
-
-::
-
-  // lib.iterator.traits, traits and tags
-  template <class Iterator> struct is_readable_iterator;
-  template <class Iterator> struct iterator_traversal;
-
-  struct incrementable_traversal_tag { };
-  struct single_pass_traversal_tag : incrementable_traversal_tag { };
-  struct forward_traversal_tag : single_pass_traversal_tag { };
-  struct bidirectional_traversal_tag : forward_traversal_tag { };
-  struct random_access_traversal_tag : bidirectional_traversal_tag { };
-
-Addition to [lib.iterator.traits]
-=================================
-
-The ``is_readable_iterator`` and ``iterator_traversal`` class
-templates satisfy the UnaryTypeTrait_ requirements.  
-
-Given an iterator type ``X``, ``is_readable_iterator<X>::value``
-yields ``true`` if, for an object ``a`` of type ``X``, ``*a`` is
-convertible to ``iterator_traits<X>::value_type``, and ``false``
-otherwise.
-
-``iterator_traversal<X>::value_type`` is defined to be:
-
-.. parsed-literal::
-
-   traversal-category(X) =
-       cat = iterator_traits<X>::iterator_category;
-       if (cat is convertible to incrementable_traversal_tag)
-           return cat;
-       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_traversal_tag;
-       else if (cat is convertible to output_iterator_tag)
-           return incrementable_traversal_tag;
-       else
-           *the program is ill-formed*
-
-
-===========
- Footnotes
-===========
-
-.. _UnaryTypeTrait: n1519_
-
-The UnaryTypeTrait concept is defined in n1519_; the LWG added the
-requirement that specializations are derived from their nested
-``::type``.
-
-.. _n1519: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1519.htm
-
-..
- 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 mis enum

doc/permutation_iterator.html

@@ -1,320 +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>Permutation Iterator</title>
-<meta name="author" content="Toon Knapen, David Abrahams, Roland Richter, Jeremy Siek" />
-<meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab" />
-<meta name="date" content="2003-09-14" />
-<meta name="copyright" content="Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. All rights reserved" />
-<style type="text/css"><!--
-
-/*
-: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 {
-  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 {
-  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.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.caption {
-  font-style: italic }
-
-p.credits {
-  font-style: italic ;
-  font-size: smaller }
-
-p.label {
-  white-space: nowrap }
-
-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-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 }
-
---></style>
-</head>
-<body>
-<div class="document" id="permutation-iterator">
-<h1 class="title">Permutation 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>Toon Knapen, David Abrahams, Roland Richter, Jeremy Siek</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="last reference" href="mailto:jsiek&#64;osl.iu.edu">jsiek&#64;osl.iu.edu</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="last reference" href="http://www.osl.iu.edu">Open Systems
-Lab</a></td></tr>
-<tr><th class="docinfo-name">Date:</th>
-<td>2003-09-14</td></tr>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. All rights reserved</td></tr>
-</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"></td>
-</tr>
-</tbody>
-</table>
-<p>The permutation iterator adaptor provides a permuted view of a given
-range. That is, the view includes every element of the given range but
-in a potentially different order.</p>
-<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="id4" name="id4">Introduction</a></li>
-<li><a class="reference" href="#reference" id="id5" name="id5">Reference</a><ul>
-<li><a class="reference" href="#permutation-iterator-requirements" id="id6" name="id6"><tt class="literal"><span class="pre">permutation_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#permutation-iterator-operations" id="id7" name="id7"><tt class="literal"><span class="pre">permutation_iterator</span></tt> operations</a></li>
-</ul>
-</li>
-</ul>
-</div>
-<div class="section" id="introduction">
-<h1><a class="toc-backref" href="#id4" name="introduction">Introduction</a></h1>
-<p>The adaptor takes two arguments:</p>
-<blockquote>
-<ul class="simple">
-<li>an iterator to the range V on which the permutation
-will be applied</li>
-<li>the reindexing scheme that defines how the
-elements of V will be permuted.</li>
-</ul>
-</blockquote>
-<p>Note that the permutation iterator is not limited to strict
-permutations of the given range V.  The distance between begin and end
-of the reindexing iterators is allowed to be smaller compared to the
-size of the range V, in which case the permutation iterator only
-provides a permutation of a subrange of V.  The indexes neither need
-to be unique. In this same context, it must be noted that the past the
-end permutation iterator is completely defined by means of the
-past-the-end iterator to the indices.</p>
-</div>
-<div class="section" id="reference">
-<h1><a class="toc-backref" href="#id5" name="reference">Reference</a></h1>
-<pre class="literal-block">
-template&lt; class ElementIterator
-        , class IndexIterator
-        , class ValueT        = use_default
-    , unsigned access     = use_default_access
-        , class Traversal     = use_default
-        , class ReferenceT    = use_default
-        , class DifferenceT   = use_default &gt;
-class permutation_iterator
-  : public iterator_adaptor&lt;...&gt;
-{
-  typedef iterator_adaptor&lt;...&gt;
-  friend class iterator_core_access;
-public:
-  permutation_iterator();
-  explicit permutation_iterator(ElementIterator x, IndexIterator y);
-
-  template&lt; class OEIter, class OIIter, class V, class C, class R, class D &gt;
-  permutation_iterator(
-      permutation_iterator&lt;OEIter, OIIter, V, C, R, D&gt; const&amp; r
-      , typename enable_if_convertible&lt;OEIter, ElementIterator&gt;::type* = 0
-      , typename enable_if_convertible&lt;OIIter, IndexIterator&gt;::type* = 0
-      );
-};
-</pre>
-<div class="section" id="permutation-iterator-requirements">
-<h2><a class="toc-backref" href="#id6" name="permutation-iterator-requirements"><tt class="literal"><span class="pre">permutation_iterator</span></tt> requirements</a></h2>
-<p><tt class="literal"><span class="pre">ElementIterator</span></tt> must be a model of <a class="reference" href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>.
-<tt class="literal"><span class="pre">IndexIterator</span></tt> must at least be a model <a class="reference" href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>.  The
-value type of the <tt class="literal"><span class="pre">IndexIterator</span></tt> must be convertible to the
-difference type of <tt class="literal"><span class="pre">ElementIterator</span></tt>.</p>
-</div>
-<div class="section" id="permutation-iterator-operations">
-<h2><a class="toc-backref" href="#id7" name="permutation-iterator-operations"><tt class="literal"><span class="pre">permutation_iterator</span></tt> operations</a></h2>
-<p>The permutation iterator implements the member functions and operators
-required for the <a class="reference" href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a> concept. However, the
-permutation iterator can only meet the complexity guarantees of the
-same concept as the IndexIterator. Thus for instance, although the
-permutation iterator provides <tt class="literal"><span class="pre">operator+=(distance)</span></tt>, this operation
-will take linear time in case the IndexIterator is a model of
-ForwardIterator instead of amortized constant time.</p>
-</div>
-</div>
-</div>
-<hr class="footer" />
-<div class="footer">
-<a class="reference" href="permutation_iterator.rst">View document source</a>.
-Generated on: 2003-11-24 05:00 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/permutation_iterator.rst

@@ -1,31 +0,0 @@
-++++++++++++++++++++++
- Permutation Iterator
-++++++++++++++++++++++
-
-:Author: Toon Knapen, David Abrahams, Roland Richter, Jeremy Siek
-:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu
-:organization: `Boost Consulting`_, Indiana University `Open Systems
-               Lab`_
-:date: $Date$
-:copyright: Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. All rights reserved
-
-.. _`Boost Consulting`: http://www.boost-consulting.com
-.. _`Open Systems Lab`: http://www.osl.iu.edu
-
-:abstract:
-
-.. include:: permutation_iterator_abstract.rst
-
-.. contents:: Table of Contents
-
-
-Introduction
-============
-
-.. include:: permutation_iterator_body.rst
-
-
-Reference
-=========
-
-.. include:: permutation_iterator_ref.rst

doc/permutation_iterator_abstract.rst

@@ -1,4 +0,0 @@
-The permutation iterator adaptor provides a permuted view of a given
-range. That is, the view includes every element of the given range but
-in a potentially different order.
-

doc/permutation_iterator_body.rst

@@ -1,15 +0,0 @@
-The adaptor takes two arguments:
-
-  * an iterator to the range V on which the permutation
-    will be applied
-  * the reindexing scheme that defines how the
-    elements of V will be permuted.
-
-Note that the permutation iterator is not limited to strict
-permutations of the given range V.  The distance between begin and end
-of the reindexing iterators is allowed to be smaller compared to the
-size of the range V, in which case the permutation iterator only
-provides a permutation of a subrange of V.  The indexes neither need
-to be unique. In this same context, it must be noted that the past the
-end permutation iterator is completely defined by means of the
-past-the-end iterator to the indices.

doc/permutation_iterator_ref.rst

@@ -1,55 +0,0 @@
-.. parsed-literal::
-
-  template< class ElementIterator
-	  , class IndexIterator
-	  , class ValueT        = use_default
-      , unsigned access     = use_default_access
-	  , class Traversal     = use_default
-	  , class ReferenceT    = use_default
-	  , class DifferenceT   = use_default >
-  class permutation_iterator
-    : public iterator_adaptor<...>
-  {
-    typedef iterator_adaptor<...>
-    friend class iterator_core_access;
-  public:
-    permutation_iterator();
-    explicit permutation_iterator(ElementIterator x, IndexIterator y);
-
-    template< class OEIter, class OIIter, class V, class C, class R, class D >
-    permutation_iterator(
-	permutation_iterator<OEIter, OIIter, V, C, R, D> const& r
-	, typename enable_if_convertible<OEIter, ElementIterator>::type* = 0
-	, typename enable_if_convertible<OIIter, IndexIterator>::type* = 0
-	);
-  };
-
-
-
-``permutation_iterator`` requirements
--------------------------------------
-
-``ElementIterator`` must be a model of RandomAccessIterator__.
-``IndexIterator`` must at least be a model ForwardIterator__.  The
-value type of the ``IndexIterator`` must be convertible to the
-difference type of ``ElementIterator``.
-
-__ http://www.sgi.com/tech/stl/RandomAccessIterator.html
-
-__ http://www.sgi.com/tech/stl/ForwardIterator.html
-
-
-
-
-``permutation_iterator`` operations
------------------------------------
-
-The permutation iterator implements the member functions and operators
-required for the `Random Access Iterator`__ concept. However, the
-permutation iterator can only meet the complexity guarantees of the
-same concept as the IndexIterator. Thus for instance, although the
-permutation iterator provides ``operator+=(distance)``, this operation
-will take linear time in case the IndexIterator is a model of
-ForwardIterator instead of amortized constant time.
-
-__ http://www.sgi.com/tech/stl/RandomAccessIterator.html

doc/ref_problem.rst

@@ -1,63 +0,0 @@
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- Problem with ``reference`` and old/new iterator category correspondance
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-.. _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
-
-==============
- Introduction
-==============
-
-The new iterator categories are intended to correspond to the old
-iterator categories, as specified in a diagram in N1550_. For example,
-an iterator categorized as a mutable Forward Iterator under the old
-scheme is now a Writable, Lvalue, and Foward Traversal iterator.
-However, there is a problem with this correspondance, the new iterator
-categories place requirements on the ``iterator_traits<X>::reference``
-type whereas the standard iterator requirements say nothing about the
-``reference`` type . In particular, the new Readable Iterator
-requirements say that the return type of ``*a`` must be
-``iterator_traits<X>::reference`` and the Lvalue Iterator requirements
-says that ``iterator_traits<X>::reference`` must be ``T&`` or ``const
-T&``.
-
-
-====================
- Proposed Resolution
-====================
-
-Change the standard requirements to match the requirements of the new
-iterators. (more details to come)
-
-
-==========
- Rationale
-==========
-
-The lack of specification in the standard of the ``reference`` type is
-certainly a defect. Without specification, it is entirely useless in a
-generic function. The current practice in the community is generally
-to assume there are requirements on the ``reference`` type, such as
-those proposed in the new iterator categories.
-
-There is some danger in *adding* requirements to existing concepts.
-This will mean that some existing iterator types will no longer meet
-the iterator requirements. However, we feel that the impact of this is
-small enough to warrant going ahead with this change.
-
-An alternative solution would be to leave the standard requirements as
-is, and to remove the requirements for the ``reference`` type in the
-new iterator concepts. We are not in favor of this approach because it
-extends what we see as a defect further into the future.

doc/reverse_iterator.html

@@ -1,143 +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>Reverse Iterator</title>
-<meta name="author" content="David Abrahams, Jeremy Siek, Thomas Witt" />
-<meta name="organization" content="Boost Consulting, Indiana University Open Systems Lab, University of Hanover Institute for Transport Railway Operation and Construction" />
-<meta name="date" content="2003-09-14" />
-<meta name="copyright" content="Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved" />
-<link rel="stylesheet" href="../../../rst.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="reverse-iterator">
-<h1 class="title">Reverse 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>2003-09-14</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"></td>
-</tr>
-</tbody>
-</table>
-<!-- I think we'd better strike the old reverse_iterator text from the standard, eh? -->
-<p>The reverse iterator adaptor flips the direction of a base iterator's
-motion. Invoking <tt class="literal"><span class="pre">operator++()</span></tt> moves the base iterator backward and
-invoking <tt class="literal"><span class="pre">operator--()</span></tt> moves the base iterator forward.</p>
-<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="#reverse-iterator-requirements" id="id1" name="id1"><tt class="literal"><span class="pre">reverse_iterator</span></tt> requirements</a></li>
-</ul>
-</div>
-<pre class="literal-block">
-template &lt;class Iterator&gt;
-class reverse_iterator :
-  public iterator_adaptor&lt; reverse_iterator&lt;Iterator&gt;, Iterator &gt;
-{
-  friend class iterator_core_access;
-public:
-  reverse_iterator() {}
-  explicit reverse_iterator(Iterator x) ;
-
-  template&lt;class OtherIterator&gt;
-  reverse_iterator(
-      reverse_iterator&lt;OtherIterator&gt; const&amp; r
-    , typename enable_if_convertible&lt;OtherIterator, Iterator&gt;::type* = 0 // exposition
-  );
-
-private: // as-if specification
-  typename reverse_iterator::reference dereference() const { return *prior(this-&gt;base()); }
-
-  void increment() { --this-&gt;base_reference(); }
-  void decrement() { ++this-&gt;base_reference(); }
-
-  void advance(typename reverse_iterator::difference_type n)
-  {
-      this-&gt;base_reference() += -n;
-  }
-
-  template &lt;class OtherIterator&gt;
-  typename reverse_iterator::difference_type
-  distance_to(reverse_iterator&lt;OtherIterator&gt; const&amp; y) const
-  {
-      return this-&gt;base_reference() - y.base();
-  }
-
-};
-</pre>
-<div class="section" id="reverse-iterator-requirements">
-<h1><a class="toc-backref" href="#id1" name="reverse-iterator-requirements"><tt class="literal"><span class="pre">reverse_iterator</span></tt> requirements</a></h1>
-<p>The base <tt class="literal"><span class="pre">Iterator</span></tt> must be a model of Bidirectional Traversal
-Iterator. The resulting <tt class="literal"><span class="pre">reverse_iterator</span></tt> will be a model of the
-most refined standard traversal and access concepts that are modeled
-by <tt class="literal"><span class="pre">Iterator</span></tt>.</p>
-<p><tt class="literal"><span class="pre">reverse_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">reverse_iterator</span></tt> with a
-default constructed base object.</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">explicit</span> <span class="pre">reverse_iterator(Iterator</span> <span class="pre">x);</span></tt></p>
-<table class="field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">reverse_iterator</span></tt> with a
-base object copy constructed from <tt class="literal"><span class="pre">x</span></tt>.</td>
-</tr>
-</tbody>
-</table>
-<pre class="literal-block">
-template&lt;class OtherIterator&gt;
-reverse_iterator(
-    reverse_iterator&lt;OtherIterator&gt; const&amp; r
-  , 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">An instance of <tt class="literal"><span class="pre">reverse_iterator</span></tt> that is a copy of <tt class="literal"><span class="pre">r</span></tt>.</td>
-</tr>
-</tbody>
-</table>
-</div>
-</div>
-<hr class="footer" />
-<div class="footer">
-<a class="reference" href="reverse_iterator.rst">View document source</a>.
-Generated on: 2003-09-21 09:35 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/reverse_iterator.rst

@@ -1,23 +0,0 @@
-++++++++++++++++++
- Reverse 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:: reverse_iterator_abstract.rst
-
-.. contents:: Table of Contents
-
-.. include:: reverse_iterator_ref.rst

doc/reverse_iterator_abstract.rst

@@ -1,6 +0,0 @@
-.. I think we'd better strike the old reverse_iterator text from the standard, eh?
-
-The reverse iterator adaptor flips the direction of a base iterator's
-motion. Invoking ``operator++()`` moves the base iterator backward and
-invoking ``operator--()`` moves the base iterator forward.
-

doc/reverse_iterator_ref.rst

@@ -1,69 +0,0 @@
-::
-
-  template <class Iterator>
-  class reverse_iterator :
-    public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
-  {
-    friend class iterator_core_access;
-  public:
-    reverse_iterator() {}
-    explicit reverse_iterator(Iterator x) ;
-
-    template<class OtherIterator>
-    reverse_iterator(
-        reverse_iterator<OtherIterator> const& r
-      , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
-    );
-
-  private: // as-if specification
-    typename reverse_iterator::reference dereference() const { return *prior(this->base()); }
-
-    void increment() { --this->base_reference(); }
-    void decrement() { ++this->base_reference(); }
-
-    void advance(typename reverse_iterator::difference_type n)
-    {
-        this->base_reference() += -n;
-    }
-
-    template <class OtherIterator>
-    typename reverse_iterator::difference_type
-    distance_to(reverse_iterator<OtherIterator> const& y) const
-    {
-        return this->base_reference() - y.base();
-    }
-
-  };
-
-
-``reverse_iterator`` requirements
-.................................
-
-The base ``Iterator`` must be a model of Bidirectional Traversal
-Iterator. The resulting ``reverse_iterator`` will be a model of the
-most refined standard traversal and access concepts that are modeled
-by ``Iterator``.
-
-
-``reverse_iterator();``
-
-:Requires: ``Iterator`` must be Default Constructible.
-:Returns: An instance of ``reverse_iterator`` with a
-  default constructed base object.
-
-``explicit reverse_iterator(Iterator x);``
-
-:Returns: An instance of ``reverse_iterator`` with a
-  base object copy constructed from ``x``.
-
-
-::
-
-    template<class OtherIterator>
-    reverse_iterator(
-        reverse_iterator<OtherIterator> const& r
-      , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
-    );
-
-:Requires: ``OtherIterator`` is implicitly convertible to ``Iterator``.
-:Returns: An instance of ``reverse_iterator`` that is a copy of ``r``.

doc/sources.py

@@ -1,18 +0,0 @@
-# This is where we list the ReStructuredText source files that form
-# the book.  When you're ready to expose a new chapter, add the
-# filename here and put links in index.rst
-
-sources = [
-'counting_iterator.rst',
-'facade-and-adaptor.rst',
-'filter_iterator.rst',
-'function_output_iterator.rst',
-'index.rst',
-'indirect_iterator.rst',
-'iterator_adaptor.rst',
-'iterator_facade.rst',
-'new-iter-concepts.rst',
-'permutation_iterator.rst',
-'reverse_iterator.rst'
-      ]
-

doc/style.tex

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

doc/transform_iterator.html

@@ -1,169 +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.0: http://docutils.sourceforge.net/" />
-<title>Transform 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="2003-08-05" />
-<meta name="copyright" content="Copyright Dave 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="transform-iterator">
-<h1 class="title">Transform 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>2003-08-05</td></tr>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright Dave 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"></td>
-</tr>
-</tbody>
-</table>
-<p>The transform iterator adapts an iterator by applying some function
-object to the result of dereferencing the iterator. In other words,
-the <tt class="literal"><span class="pre">operator*</span></tt> of the transform iterator first dereferences the
-base iterator, passes the result of this to the function object, and
-then returns the result.</p>
-<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="#transform-iterator-requirements" id="id1" name="id1"><tt class="literal"><span class="pre">transform_iterator</span></tt> requirements</a></li>
-<li><a class="reference" href="#transform-iterator-public-operations" id="id2" name="id2"><tt class="literal"><span class="pre">transform_iterator</span></tt> public operations</a></li>
-<li><a class="reference" href="#transform-iterator-private-operations" id="id3" name="id3"><tt class="literal"><span class="pre">transform_iterator</span></tt> private operations</a></li>
-</ul>
-</div>
-<pre class="literal-block">
-template &lt;class AdaptableUnaryFunction,
-          class Iterator, 
-          class Reference = use_default, 
-          class Value = use_default&gt;
-class transform_iterator
-  : public iterator_adaptor&lt;/* see discussion */&gt;
-{
-  friend class iterator_core_access;
-public:
-  transform_iterator();
-  transform_iterator(Iterator const&amp; x, AdaptableUnaryFunction f);
-
-  template&lt;class OtherIterator, class R2, class V2&gt;
-  transform_iterator(
-        transform_iterator&lt;AdaptableUnaryFunction, OtherIterator, R2, V2&gt; const&amp; t
-      , typename enable_if_convertible&lt;OtherIterator, Iterator&gt;::type* = 0 // exposition
-  );
-
-  AdaptableUnaryFunction functor() const;
-private:
-  typename transform_iterator::value_type dereference() const;
-  AdaptableUnaryFunction m_f;
-};
-</pre>
-<div class="section" id="transform-iterator-requirements">
-<h1><a class="toc-backref" href="#id1" name="transform-iterator-requirements"><tt class="literal"><span class="pre">transform_iterator</span></tt> requirements</a></h1>
-<p>The type <tt class="literal"><span class="pre">AdaptableUnaryFunction</span></tt> must be Assignable, Copy
-Constructible, and the expression <tt class="literal"><span class="pre">f(x)</span></tt> must be valid where <tt class="literal"><span class="pre">f</span></tt>
-is an object of type <tt class="literal"><span class="pre">AdaptableUnaryFunction</span></tt>, <tt class="literal"><span class="pre">x</span></tt> is an object of
-type <tt class="literal"><span class="pre">AdaptableUnaryFunction::argument_type</span></tt>, and where the type of
-<tt class="literal"><span class="pre">f(x)</span></tt> must be <tt class="literal"><span class="pre">AdaptableUnaryFunction::result_type</span></tt>.</p>
-<p>The type <tt class="literal"><span class="pre">Iterator</span></tt> must at least model Readable Iterator.  The
-resulting <tt class="literal"><span class="pre">transform_iterator</span></tt> models the most refined of the
-following options that is also modeled by <tt class="literal"><span class="pre">Iterator</span></tt>.</p>
-<blockquote>
-<ul class="simple">
-<li>Writable Lvalue Iterator if the <tt class="literal"><span class="pre">result_type</span></tt> of the
-<tt class="literal"><span class="pre">AdaptableUnaryFunction</span></tt> is a non-const reference.</li>
-<li>Readable Lvalue Iterator if the <tt class="literal"><span class="pre">result_type</span></tt> is a const
-reference.</li>
-<li>Readable Iterator otherwise.</li>
-</ul>
-</blockquote>
-<p>The <tt class="literal"><span class="pre">transform_iterator</span></tt> models the most refined standard traversal
-concept that is modeled by <tt class="literal"><span class="pre">Iterator</span></tt>.</p>
-<p>The <tt class="literal"><span class="pre">value_type</span></tt> of <tt class="literal"><span class="pre">transform_iterator</span></tt> is
-<tt class="literal"><span class="pre">remove_reference&lt;result_type&gt;::type</span></tt>. The <tt class="literal"><span class="pre">reference</span></tt> type is
-<tt class="literal"><span class="pre">result_type</span></tt>.</p>
-</div>
-<div class="section" id="transform-iterator-public-operations">
-<h1><a class="toc-backref" href="#id2" name="transform-iterator-public-operations"><tt class="literal"><span class="pre">transform_iterator</span></tt> public operations</a></h1>
-<p><tt class="literal"><span class="pre">transform_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">An instance of <tt class="literal"><span class="pre">transform_iterator</span></tt> with <tt class="literal"><span class="pre">m_f</span></tt>
-and <tt class="literal"><span class="pre">m_iterator</span></tt> default constructed.</td>
-</tr>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">transform_iterator(Iterator</span> <span class="pre">const&amp;</span> <span class="pre">x,</span> <span class="pre">AdaptableUnaryFunction</span> <span class="pre">f);</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">transform_iterator</span></tt> with <tt class="literal"><span class="pre">m_f</span></tt>
-initialized to <tt class="literal"><span class="pre">f</span></tt> and <tt class="literal"><span class="pre">m_iterator</span></tt> initialized to <tt class="literal"><span class="pre">x</span></tt>.</td>
-</tr>
-</tbody>
-</table>
-<pre class="literal-block">
-template&lt;class OtherIterator, class R2, class V2&gt;
-transform_iterator(
-      transform_iterator&lt;AdaptableUnaryFunction, OtherIterator, R2, V2&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">Returns:</th><td class="field-body">An instance of <tt class="literal"><span class="pre">transform_iterator</span></tt> that is a copy of <tt class="literal"><span class="pre">t</span></tt>.</td>
-</tr>
-<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>
-</tbody>
-</table>
-<p><tt class="literal"><span class="pre">AdaptableUnaryFunction</span> <span class="pre">functor()</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_f</span></tt></td>
-</tr>
-</tbody>
-</table>
-</div>
-<div class="section" id="transform-iterator-private-operations">
-<h1><a class="toc-backref" href="#id3" name="transform-iterator-private-operations"><tt class="literal"><span class="pre">transform_iterator</span></tt> private operations</a></h1>
-<p><tt class="literal"><span class="pre">typename</span> <span class="pre">transform_iterator::value_type</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_f(transform_iterator::dereference());</span></tt></td>
-</tr>
-</tbody>
-</table>
-</div>
-</div>
-</body>
-</html>

doc/transform_iterator.rst

@@ -1,23 +0,0 @@
-++++++++++++++++++++
- Transform 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:: transform_iterator_abstract.rst
-
-.. contents:: Table of Contents
-
-.. include:: transform_iterator_ref.rst

doc/transform_iterator_abstract.rst

@@ -1,5 +0,0 @@
-The transform iterator adapts an iterator by applying some function
-object to the result of dereferencing the iterator. In other words,
-the ``operator*`` of the transform iterator first dereferences the
-base iterator, passes the result of this to the function object, and
-then returns the result.

doc/transform_iterator_ref.rst

@@ -1,96 +0,0 @@
-.. Version 1.3 of this document was accepted for TR1
-
-::
-
-  template <class UnaryFunction,
-            class Iterator, 
-            class Reference = use_default, 
-            class Value = use_default>
-  class transform_iterator
-    : public iterator_adaptor</* see discussion */>
-  {
-    friend class iterator_core_access;
-  public:
-    transform_iterator();
-    transform_iterator(Iterator const& x, UnaryFunction f);
-
-    template<class F2, class I2, class R2, class V2>
-    transform_iterator(
-          transform_iterator<F2, I2, R2, V2> const& t
-        , typename enable_if_convertible<I2, Iterator>::type* = 0      // exposition
-        , typename enable_if_convertible<F2, UnaryFunction>::type* = 0 // exposition
-    );
-
-    UnaryFunction functor() const;
-  private:
-    typename transform_iterator::value_type dereference() const;
-    UnaryFunction m_f;
-  };
-
-
-``transform_iterator`` requirements
-...................................
-
-The type ``UnaryFunction`` must be Assignable, Copy Constructible, and
-the expression ``f(*i)`` must be valid where ``f`` is an object of
-type ``UnaryFunction``, ``i`` is an object of type ``Iterator``, and
-where the type of ``f(*i)`` must be
-``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
-
-The type ``Iterator`` must at least model Readable Iterator.  The
-resulting ``transform_iterator`` models the most refined of the
-following options that is also modeled by ``Iterator``.
-
-  * Writable Lvalue Iterator if ``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type`` is a non-const reference. 
-
-  * Readable Lvalue Iterator if ``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type`` is a const
-    reference.
-
-  * Readable Iterator otherwise. 
-
-
-The ``transform_iterator`` models the most refined standard traversal
-concept that is modeled by ``Iterator``.
-
-The ``reference`` type of ``transform_iterator`` is
-``result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type``.
-The ``value_type`` is ``remove_cv<remove_reference<reference> >::type``.
-
-``transform_iterator`` public operations
-........................................
-
-
-``transform_iterator();``
-
-:Returns: An instance of ``transform_iterator`` with ``m_f``
-  and ``m_iterator`` default constructed.
-
-
-``transform_iterator(Iterator const& x, UnaryFunction f);``
-
-:Returns: An instance of ``transform_iterator`` with ``m_f``
-  initialized to ``f`` and ``m_iterator`` initialized to ``x``.
-
-
-::
-
-    template<class OtherIterator, class R2, class V2>
-    transform_iterator(
-          transform_iterator<UnaryFunction, OtherIterator, R2, V2> const& t
-        , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
-    );
-
-:Returns: An instance of ``transform_iterator`` that is a copy of ``t``.
-:Requires: ``OtherIterator`` is implicitly convertible to ``Iterator``.
-
-``UnaryFunction functor() const;``
-
-:Returns: ``m_f``
-
-``transform_iterator`` private operations
-.........................................
-
-``typename transform_iterator::value_type dereference() const;``
-
-:Returns: ``m_f(transform_iterator::dereference());``
-

example/Jamfile

@@ -1 +0,0 @@
-unit-test ia1 : reverse_iterator.cpp : <sysinclude>../../.. <sysinclude>$(BOOST) ;

example/reverse_iterator.cpp

@@ -1,16 +0,0 @@
-#include <boost/iterator/iterator_adaptors.hpp>
-#include <boost/cstdlib.hpp>
-#include <iostream>
-#include <iterator>
-#include <algorithm>
-
-int main()
-{
-  int x[] = { 1, 2, 3, 4 };
-  boost::reverse_iterator<int*, int, int&, int*, 
-    boost::iterator_tag<boost::mutable_lvalue_iterator_tag, boost::random_access_traversal_tag>
-    , std::ptrdiff_t> first(x + 4), last(x);
-  std::copy(first, last, std::ostream_iterator<int>(std::cout, " "));
-  std::cout << std::endl;
-  return 0;
-}

include/boost/function_output_iterator.hpp

@@ -1,8 +1,7 @@
-// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// (C) Copyright Jeremy Siek 2001.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 
 // Revision History:
 
@@ -26,7 +25,9 @@ namespace boost {
     typedef void                pointer;
     typedef void                reference;
 
-    explicit function_output_iterator(const UnaryFunction& f = UnaryFunction())
+    explicit function_output_iterator() {}
+
+    explicit function_output_iterator(const UnaryFunction& f)
       : m_f(f) {}
 
     struct output_proxy {

include/boost/half_open_range.hpp

@@ -1,426 +0,0 @@
-// (C) Copyright Jeremy Siek and David Abrahams 2000-2001. Permission to copy,
-// use, modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided "as is"
-// without express or implied warranty, and with no claim as to its suitability
-// for any purpose.
-//
-// Revision History:
-// 11 Feb 2001  Use new iterator_adaptor interface, Fixes for Borland.
-//              (Dave Abrahams)
-// 04 Feb 2001  Support for user-defined iterator categories (Dave Abrahams)
-// 30 Jan 2001  Initial Checkin (Dave Abrahams)
-
-#ifndef BOOST_HALF_OPEN_RANGE_HPP_
-# define BOOST_HALF_OPEN_RANGE_HPP_
-
-# include <boost/counting_iterator.hpp>
-# include <functional>
-# include <cassert>
-# include <boost/operators.hpp>
-# include <string>
-# include <stdexcept>
-# include <iterator>
-
-namespace boost {
-
-namespace detail {
-
-  // Template class choose_finish -- allows us to maintain the invariant that
-  // start() <= finish() on half_open_range specializations that support random
-  // access.
-#ifdef __MWERKS__
-  template <class T>
-  const T& choose_finish(const T&, const T& finish, std::input_iterator_tag)
-  {
-      return finish;
-  }
-
-  template <class T>
-  const T& choose_finish(const T&, const T& finish, std::output_iterator_tag)
-  {
-      return finish;
-  }
-
-  template <class T>
-  const T& choose_finish(const T& start, const T& finish, std::random_access_iterator_tag)
-  {
-      return finish < start ? start : finish;
-  }
-#else
-  template <bool is_random_access> struct finish_chooser;
-
-  template <>
-  struct finish_chooser<false>
-  {
-      template <class T>
-      struct rebind
-      {
-          static T choose(const T&, const T& finish)
-              { return finish; }
-      };
-  };
-
-  template <>
-  struct finish_chooser<true>
-  {
-      template <class T>
-      struct rebind
-      {
-          static T choose(const T& start, const T& finish)
-              { return finish < start ? start : finish; }
-      };
-  };
-
-  template <class Category, class Incrementable>
-  struct choose_finish
-  {
-      static const Incrementable choose(const Incrementable& start, const Incrementable& finish)
-      {
-          return finish_chooser<(
-              ::boost::is_convertible<Category*,std::random_access_iterator_tag*>::value
-              )>::template rebind<Incrementable>::choose(start, finish);
-      }
-  };
-#endif
-}
-
-template <class Incrementable>
-struct half_open_range
-{
-    typedef typename counting_iterator_generator<Incrementable>::type iterator;
-
- private: // utility type definitions
-    // Using iter_t prevents compiler confusion with boost::iterator
-    typedef typename counting_iterator_generator<Incrementable>::type iter_t;
-
-    typedef std::less<Incrementable> less_value;
-    typedef typename iter_t::iterator_category category;
-    typedef half_open_range<Incrementable> self;
-
- public:
-    typedef iter_t const_iterator;
-    typedef typename iterator::value_type value_type;
-    typedef typename iterator::difference_type difference_type;
-    typedef typename iterator::reference reference;
-    typedef typename iterator::reference const_reference;
-    typedef typename iterator::pointer pointer;
-    typedef typename iterator::pointer const_pointer;
-    
-    // It would be nice to select an unsigned type, but this is appropriate
-    // since the library makes an attempt to select a difference_type which can
-    // hold the difference between any two iterators.
-    typedef typename iterator::difference_type size_type;
-
-    half_open_range(Incrementable start, Incrementable finish)
-        : m_start(start),
-          m_finish(
-#ifndef __MWERKS__
-            detail::choose_finish<category,Incrementable>::choose(start, finish)
-#else
-            detail::choose_finish(start, finish, category())
-#endif
-              )
-        {}
-
-    // Implicit conversion from std::pair<Incrementable,Incrementable> allows us
-    // to accept the results of std::equal_range(), for example.
-    half_open_range(const std::pair<Incrementable,Incrementable>& x)
-        : m_start(x.first),
-          m_finish(
-#ifndef __MWERKS__
-              detail::choose_finish<category,Incrementable>::choose(x.first, x.second)
-#else
-            detail::choose_finish(x.first, x.second, category())
-#endif
-              )
-        {}
-
-    half_open_range& operator=(const self& x)
-    {
-        m_start = x.m_start;
-        m_finish = x.m_finish;
-        return *this;
-    }
-    
-    half_open_range& operator=(const std::pair<Incrementable,Incrementable>& x)
-    {
-        m_start = x.first;
-        m_finish =
-#ifndef __MWERKS__
-            detail::choose_finish<category,Incrementable>::choose(x.first, x.second);
-#else
-            detail::choose_finish(x.first, x.second, category();
-#endif
-    }
-        
-    iterator begin() const { return iterator(m_start); }
-    iterator end() const { return iterator(m_finish); }
-    
-    Incrementable front() const { assert(!this->empty()); return m_start; }
-    Incrementable back() const { assert(!this->empty()); return boost::prior(m_finish); }
-                                     
-    Incrementable start() const { return m_start; }
-    Incrementable finish() const { return m_finish; }
-    
-    size_type size() const { return boost::detail::distance(begin(), end()); }
-
-    bool empty() const
-    {
-        return m_finish == m_start;
-    }
-
-    void swap(half_open_range& x) {
-        std::swap(m_start, x.m_start);
-        std::swap(m_finish, x.m_finish);
-    }
-    
- public: // functions requiring random access elements
-    
-    // REQUIRES: x is reachable from this->front()
-    bool contains(const value_type& x) const
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        return !less_value()(x, m_start) && less_value()(x, m_finish);
-    }
-
-    bool contains(const half_open_range& x) const
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        return x.empty() || !less_value()(x.m_start, m_start) && !less_value()(m_finish, x.m_finish);
-    }
-
-    bool intersects(const half_open_range& x) const
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        return less_value()(
-            less_value()(this->m_start, x.m_start) ? x.m_start : this->m_start,
-            less_value()(this->m_finish, x.m_finish) ? this->m_finish : x.m_finish);
-    }
-
-    half_open_range& operator&=(const half_open_range& x)
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        
-        if (less_value()(this->m_start, x.m_start))
-            this->m_start = x.m_start;
-        
-        if (less_value()(x.m_finish, this->m_finish))
-            this->m_finish = x.m_finish;
-
-        if (less_value()(this->m_finish, this->m_start))
-            this->m_start = this->m_finish;
-
-        return *this;
-    }
-
-    half_open_range& operator|=(const half_open_range& x)
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-
-        if (!x.empty())
-        {
-            if (this->empty())
-            {
-                *this = x;
-            }
-            else
-            {
-                if (less_value()(x.m_start, this->m_start))
-                    this->m_start = x.m_start;
-        
-                if (less_value()(this->m_finish, x.m_finish))
-                    this->m_finish = x.m_finish;
-            }
-        }
-        return *this;
-    }
-
-    // REQUIRES: x is reachable from this->front()
-    const_iterator find(const value_type& x) const
-    {
-        BOOST_STATIC_ASSERT((boost::is_same<category, std::random_access_iterator_tag>::value));
-        
-        return const_iterator(this->contains(x) ? x : m_finish);
-    }
-
-    // REQUIRES: index >= 0 && index < size()
-    value_type operator[](size_type index) const
-    {
-        assert(index >= 0 && index < size());
-        return m_start + index;
-    }
-    
-    value_type at(size_type index) const
-    {
-        if (index < 0 || index >= size())
-            throw std::out_of_range(std::string("half_open_range"));
-        return m_start + index;
-    }
-    
- private: // data members
-    Incrementable m_start, m_finish;
-};
-
-template <class Incrementable>
-half_open_range<Incrementable> operator|(
-    half_open_range<Incrementable> x,
-    const half_open_range<Incrementable>& y)
-{
-    return x |= y;
-}
-
-template <class Incrementable>
-half_open_range<Incrementable> operator&(
-    half_open_range<Incrementable> x,
-    const half_open_range<Incrementable>& y)
-{
-    return x &= y;
-}
-
-template <class Incrementable>
-inline bool operator==(
-    const half_open_range<Incrementable>& x,
-    const half_open_range<Incrementable>& y)
-{
-    const bool y_empty = y.empty();
-    return x.empty() ? y_empty : !y_empty && x.start() == y.start() && x.finish() == y.finish();
-}
-
-template <class Incrementable>
-inline bool operator!=(
-    const half_open_range<Incrementable>& x,
-    const half_open_range<Incrementable>& y)
-{
-    return !(x == y);
-}
-
-template <class Incrementable>
-inline half_open_range<Incrementable>
-make_half_open_range(Incrementable first, Incrementable last)
-{
-  return half_open_range<Incrementable>(first, last);
-}
-
-template <class Incrementable>
-bool intersects(
-    const half_open_range<Incrementable>& x,
-    const half_open_range<Incrementable>& y)
-{
-    return x.intersects(y);
-}
-    
-template <class Incrementable>
-bool contains(
-    const half_open_range<Incrementable>& x,
-    const half_open_range<Incrementable>& y)
-{
-    return x.contains(y);
-}
-    
-} // namespace boost
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace std {
-template <class Incrementable> struct less<boost::half_open_range<Incrementable> >
-        : binary_function<
-            boost::half_open_range<Incrementable>,
-            boost::half_open_range<Incrementable>,bool>
-{
-    bool operator()(
-        const boost::half_open_range<Incrementable>& x,
-        const boost::half_open_range<Incrementable>& y) const
-    {
-        less<Incrementable> cmp;
-        return !y.empty() && (
-            cmp(x.start(), y.start())
-            || !cmp(y.start(), x.start())
-               && cmp(x.finish(), y.finish()));
-    }
-};
-
-template <class Incrementable> struct less_equal<boost::half_open_range<Incrementable> >
-        : binary_function<
-            boost::half_open_range<Incrementable>,
-            boost::half_open_range<Incrementable>,bool>
-{
-    bool operator()(
-        const boost::half_open_range<Incrementable>& x,
-        const boost::half_open_range<Incrementable>& y) const
-    {
-        typedef boost::half_open_range<Incrementable> range;
-        less<range> cmp;
-        return !cmp(y,x);
-    }
-};
-template <class Incrementable> struct greater<boost::half_open_range<Incrementable> >
-        : binary_function<
-            boost::half_open_range<Incrementable>,
-            boost::half_open_range<Incrementable>,bool>
-{
-    bool operator()(
-        const boost::half_open_range<Incrementable>& x,
-        const boost::half_open_range<Incrementable>& y) const
-    {
-        typedef boost::half_open_range<Incrementable> range;
-        less<range> cmp;
-        return cmp(y,x);
-    }
-};
-
-template <class Incrementable> struct greater_equal<boost::half_open_range<Incrementable> >
-        : binary_function<
-            boost::half_open_range<Incrementable>,
-            boost::half_open_range<Incrementable>,bool>
-{
-    bool operator()(
-        const boost::half_open_range<Incrementable>& x,
-        const boost::half_open_range<Incrementable>& y) const
-    {
-        typedef boost::half_open_range<Incrementable> range;
-        less<range> cmp;
-        return !cmp(x,y);
-    }
-};
-} // namespace std
-
-#else
-
-namespace boost {
-// Can't partially specialize std::less et al, so we must provide the operators
-template <class Incrementable>
-bool operator<(const half_open_range<Incrementable>& x,
-               const half_open_range<Incrementable>& y)
-{
-    return !y.empty() && (
-        x.empty() || std::less<Incrementable>()(x.start(), y.start())
-        || !std::less<Incrementable>()(y.start(), x.start())
-                && std::less<Incrementable>()(x.finish(), y.finish()));
-}
-
-template <class Incrementable>
-bool operator>(const half_open_range<Incrementable>& x,
-               const half_open_range<Incrementable>& y)
-{
-    return y < x;
-}
-
-template <class Incrementable>
-bool operator<=(const half_open_range<Incrementable>& x,
-               const half_open_range<Incrementable>& y)
-{
-    return !(y < x);
-}
-
-template <class Incrementable>
-bool operator>=(const half_open_range<Incrementable>& x,
-               const half_open_range<Incrementable>& y)
-{
-    return !(x < y);
-}
-} // namespace boost
-
-#endif
-    
-
-#endif // BOOST_HALF_OPEN_RANGE_HPP_

include/boost/iterator.hpp

@@ -1,9 +1,8 @@
 //  interator.hpp workarounds for non-conforming standard libraries  ---------//
 
-//  (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
+//  (C) Copyright Beman Dawes 2000. Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org/libs/utility for documentation.
 
@@ -53,7 +52,7 @@ namespace boost
 
   template <class Category, class T, class Distance = std::ptrdiff_t,
             class Pointer = T*, class Reference = T&>
-   struct iterator : detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
+  struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
 # endif
 } // namespace boost
 

include/boost/iterator/counting_iterator.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2003. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// Copyright David Abrahams 2003.
+// 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)
 #ifndef COUNTING_ITERATOR_DWA200348_HPP
 # define COUNTING_ITERATOR_DWA200348_HPP
 
@@ -11,7 +10,7 @@
 # include <boost/mpl/bool.hpp>
 # include <boost/mpl/if.hpp>
 # include <boost/mpl/identity.hpp>
-# include <boost/mpl/apply_if.hpp>
+# include <boost/mpl/eval_if.hpp>
 
 namespace boost {
 
@@ -58,11 +57,11 @@ namespace detail
 
 #  if defined(BOOST_HAS_LONG_LONG)
   template <>
-  struct is_numeric<long long>
+  struct is_numeric< ::boost::long_long_type>
     : mpl::true_ {};
   
   template <>
-  struct is_numeric<unsigned long long>
+  struct is_numeric< ::boost::ulong_long_type>
     : mpl::true_ {};
 #  endif
 
@@ -84,7 +83,7 @@ namespace detail
   {
       typedef typename detail::ia_dflt_help<
           CategoryOrTraversal
-        , mpl::apply_if<
+        , mpl::eval_if<
               is_numeric<Incrementable>
             , mpl::identity<random_access_traversal_tag>
             , iterator_traversal<Incrementable>
@@ -93,7 +92,7 @@ namespace detail
       
       typedef typename detail::ia_dflt_help<
           Difference
-        , mpl::apply_if<
+        , mpl::eval_if<
               is_numeric<Incrementable>
             , numeric_difference<Incrementable>
             , iterator_difference<Incrementable>
@@ -127,7 +126,7 @@ namespace detail
   {
       static Difference distance(Incrementable1 x, Incrementable2 y)
       {
-          return boost::detail::distance(x, y);
+          return y - x;
       }
   };
 

include/boost/iterator/detail/categories.hpp

@@ -1 +0,0 @@
-#error obsolete

include/boost/iterator/detail/config_def.hpp

@@ -1,11 +1,9 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 
 // no include guard multiple inclusion intended
 
@@ -24,7 +22,11 @@
 # define BOOST_ITERATOR_CONFIG_DEF
 #endif 
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
+// We enable this always now.  Otherwise, the simple case in
+// libs/iterator/test/constant_iterator_arrow.cpp fails to compile
+// because the operator-> return is improperly deduced as a non-const
+// pointer.
+#if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
     || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))
 
 // Recall that in general, compilers without partial specialization
@@ -38,7 +40,7 @@
 // end up using a proxy for operator[] when we otherwise shouldn't.
 // Using reference constness gives it an extra hint that it can
 // return the value_type from operator[] directly, but is not
-// strictly neccessary.  Not sure how best to resolve this one.
+// strictly necessary.  Not sure how best to resolve this one.
 
 # define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
 
@@ -46,7 +48,8 @@
 
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                       \
     || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))                   \
-    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER))
+    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
+    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
 # define BOOST_NO_LVALUE_RETURN_DETECTION
 
 # if 0 // test code
@@ -83,10 +86,13 @@
 #  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
 #endif
 
-#if BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(3)) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+#if BOOST_WORKAROUND(__GNUC__, == 2)                                                                            \
+    || BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__)   \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 #  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
 
 #  if 0 // test code
+    #include <boost/type_traits/is_convertible.hpp>
     template <class T>
     struct foo
     {
@@ -109,7 +115,7 @@
 # define BOOST_ITERATOR_NO_MPL_AUX_HAS_XXX  // "MPL's has_xxx facility doesn't work"
 #endif 
 
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE)
+#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))
 # define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #endif 
 
@@ -119,4 +125,16 @@
 #  define BOOST_ARG_DEPENDENT_TYPENAME
 # endif
 
-// no include guard multiple inclusion intended
+# if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+
+// GCC-2.95 eagerly instantiates templated constructors and conversion
+// operators in convertibility checks, causing premature errors.
+//
+// Borland's problems are harder to diagnose due to lack of an
+// instantiation stack backtrace.  They may be due in part to the fact
+// that it drops cv-qualification willy-nilly in templates.
+#  define BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+# endif 
+
+// no include guard; multiple inclusion intended

include/boost/iterator/detail/config_undef.hpp

@@ -1,9 +1,7 @@
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 
 // no include guard multiple inclusion intended
 
@@ -18,6 +16,7 @@
 #undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #undef BOOST_ARG_DEPENDENT_TYPENAME
 #undef BOOST_NO_LVALUE_RETURN_DETECTION
+#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
 
 #ifdef BOOST_ITERATOR_CONFIG_DEF
 # undef BOOST_ITERATOR_CONFIG_DEF

include/boost/iterator/detail/enable_if.hpp

@@ -1,11 +1,9 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 #ifndef BOOST_ENABLE_IF_23022003THW_HPP
 #define BOOST_ENABLE_IF_23022003THW_HPP
 
@@ -74,7 +72,7 @@ namespace boost
       : mpl::identity<Return>
 # endif 
     {
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
         typedef Return type;
 # endif 
     };

include/boost/iterator/detail/facade_iterator_category.hpp

@@ -11,7 +11,7 @@
 # include <boost/mpl/or.hpp>  // used in iterator_tag inheritance logic
 # include <boost/mpl/and.hpp>
 # include <boost/mpl/if.hpp>
-# include <boost/mpl/apply_if.hpp>
+# include <boost/mpl/eval_if.hpp>
 # include <boost/mpl/identity.hpp>
 
 # include <boost/type_traits/is_same.hpp>
@@ -24,7 +24,7 @@
 # include <boost/iterator/detail/config_def.hpp> // try to keep this last
 
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-#  include <boost/python/detail/indirect_traits.hpp>
+#  include <boost/detail/indirect_traits.hpp>
 # endif
 
 //
@@ -61,7 +61,7 @@ struct iterator_writability_disabled
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic?
   : mpl::or_<
         is_const<Reference>
-      , python::detail::is_reference_to_const<Reference>
+      , boost::detail::indirect_traits::is_reference_to_const<Reference>
       , is_const<ValueParam>
     >
 # else 
@@ -86,12 +86,12 @@ struct iterator_writability_disabled
 //
 template <class Traversal, class ValueParam, class Reference>
 struct iterator_facade_default_category
-  : mpl::apply_if<
+  : mpl::eval_if<
         mpl::and_<
             is_reference<Reference>
           , is_convertible<Traversal,forward_traversal_tag>
         >
-      , mpl::apply_if<
+      , mpl::eval_if<
             is_convertible<Traversal,random_access_traversal_tag>
           , mpl::identity<std::random_access_iterator_tag>
           , mpl::if_<
@@ -100,20 +100,15 @@ struct iterator_facade_default_category
               , std::forward_iterator_tag
             >
         >
-      , typename mpl::apply_if<
+      , typename mpl::eval_if<
             mpl::and_<
                 is_convertible<Traversal, single_pass_traversal_tag>
                 
                 // check for readability
               , is_convertible<Reference, ValueParam>
             >
-          , mpl::if_<
-                iterator_writability_disabled<ValueParam,Reference>
-              , std::input_iterator_tag
-              , input_output_iterator_tag
-            >
-            
-          , mpl::identity<std::output_iterator_tag>
+          , mpl::identity<std::input_iterator_tag>
+          , mpl::identity<Traversal>
         >
     >
 {
@@ -199,7 +194,7 @@ struct facade_iterator_category_impl
 //
 template <class CategoryOrTraversal, class ValueParam, class Reference>
 struct facade_iterator_category
-  : mpl::apply_if<
+  : mpl::eval_if<
         is_iterator_category<CategoryOrTraversal>
       , mpl::identity<CategoryOrTraversal> // old-style categories are fine as-is
       , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>

include/boost/iterator/detail/minimum_category.hpp

@@ -21,7 +21,17 @@ namespace boost { namespace detail {
 //
 //
 template <bool GreaterEqual, bool LessEqual>
-struct minimum_category_impl;
+struct minimum_category_impl
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+{
+    template <class T1, class T2> struct apply
+    {
+        typedef T2 type;
+    };
+    typedef void type;
+}
+# endif 
+;
 
 template <class T1, class T2>
 struct error_not_related_by_convertibility;
@@ -58,25 +68,25 @@ template <>
 struct minimum_category_impl<false,false>
 {
     template <class T1, class T2> struct apply
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
-    {
-        typedef void type;
-    };
-# else 
     : error_not_related_by_convertibility<T1,T2>
     {
     };
-# endif 
 };
 
 template <class T1 = mpl::_1, class T2 = mpl::_2>
 struct minimum_category
 {
     typedef minimum_category_impl< 
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
+        is_same<T2,int>::value ||
+# endif 
         ::boost::is_convertible<T1,T2>::value
       , ::boost::is_convertible<T2,T1>::value
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
+        || is_same<T1,int>::value
+# endif 
     > outer;
-      
+
     typedef typename outer::template apply<T1,T2> inner;
     typedef typename inner::type type;
       
@@ -89,16 +99,18 @@ struct minimum_category<mpl::_1,mpl::_2>
     template <class T1, class T2>
     struct apply : minimum_category<T1,T2>
     {};
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2))
 };
-    
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
 template <>
 struct minimum_category<int,int>
 {
     typedef int type;
 };
 # endif
-
+    
 }} // namespace boost::detail
 
 #endif // MINIMUM_CATEGORY_DWA20031119_HPP

include/boost/iterator/filter_iterator.hpp

@@ -1,11 +1,9 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 #ifndef BOOST_FILTER_ITERATOR_23022003THW_HPP
 #define BOOST_FILTER_ITERATOR_23022003THW_HPP
 
@@ -33,9 +31,9 @@ namespace boost
           , typename mpl::if_<
                 is_convertible<
                     typename iterator_traversal<Iterator>::type
-                  , bidirectional_traversal_tag
+                  , random_access_traversal_tag
                 >
-              , forward_traversal_tag
+              , bidirectional_traversal_tag
               , use_default
             >::type
         > type;
@@ -124,7 +122,7 @@ namespace boost
         , Iterator
       >::type x
     , Iterator end = Iterator()
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
     , Predicate* = 0
 #endif 
   )

include/boost/iterator/indirect_iterator.hpp

@@ -1,29 +1,31 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 #ifndef BOOST_INDIRECT_ITERATOR_23022003THW_HPP
 #define BOOST_INDIRECT_ITERATOR_23022003THW_HPP
 
 #include <boost/iterator.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 
-#include <boost/iterator/iterator_traits.hpp>
+#include <boost/pointee.hpp>
+#include <boost/indirect_reference.hpp>
+#include <boost/detail/iterator.hpp>
 
-#include <boost/type_traits/remove_cv.hpp>
+#include <boost/detail/indirect_traits.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/add_reference.hpp>
 
-#include <boost/python/detail/indirect_traits.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/identity.hpp>
-#include <boost/mpl/apply_if.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/not.hpp>
-#include <boost/mpl/aux_/has_xxx.hpp>
+#include <boost/mpl/has_xxx.hpp>
 
-#ifdef BOOST_MPL_NO_AUX_HAS_XXX
+#ifdef BOOST_MPL_CFG_NO_HAS_XXX
 # include <boost/shared_ptr.hpp>
 # include <boost/scoped_ptr.hpp>
 # include <boost/mpl/bool.hpp>
@@ -37,116 +39,8 @@ namespace boost
   template <class Iter, class Value, class Category, class Reference, class Difference>
   class indirect_iterator;
 
-  template <class T>
-  struct referent;
-  
   namespace detail
   {
-    struct unspecified {};
-
-    //
-    // Detection for whether a type has a nested `element_type'
-    // typedef. Used to detect smart pointers. For compilers not
-    // supporting mpl's has_xxx, we supply specializations. However, we
-    // really ought to have a specializable is_pointer template which
-    // can be used instead with something like
-    // boost/python/pointee.hpp to find the value_type.
-    //
-# ifndef BOOST_MPL_NO_AUX_HAS_XXX
-    namespace aux
-    {
-      BOOST_MPL_HAS_XXX_TRAIT_DEF(element_type)
-    }
-
-    template <class T>
-    struct has_element_type
-        : mpl::bool_<
-              mpl::if_<
-                  is_class<T>
-                , ::boost::detail::aux::has_element_type<T>
-                , mpl::false_
-              >::type::value
-          >
-    {
-    };
-# else
-    template <class T>
-    struct has_element_type
-        : mpl::false_ {};
-    
-    template <class T>
-    struct has_element_type<boost::shared_ptr<T> >
-        : mpl::true_ {};
-    
-    template <class T>
-    struct has_element_type<boost::scoped_ptr<T> >
-        : mpl::true_ {};
-    
-    template <class T>
-    struct has_element_type<std::auto_ptr<T> >
-        : mpl::true_ {};
-# endif 
-  
-    // Metafunction accessing the nested ::element_type
-    template <class T>
-    struct element_type
-      : mpl::identity<typename T::element_type>
-    {};
-
-    template <class T>
-    struct iterator_is_mutable
-        : mpl::not_<
-              boost::python::detail::is_reference_to_const<
-                 typename iterator_reference<T>::type
-              >
-          >
-    {
-    };
-
-    template <class T>
-    struct not_int_impl
-    {
-        template <class U>
-        struct apply {
-            typedef T type;
-        };
-    };
-
-    template <>
-    struct not_int_impl<int> {};
-    
-    template <class T, class U>
-    struct not_int
-        : not_int_impl<T>::template apply<U> {};
-
-
-    template <class Dereferenceable>
-    struct class_has_element_type
-      : mpl::and_<
-            is_class<Dereferenceable>
-          , has_element_type<Dereferenceable>
-        >
-    {};
-
-    // If the Value parameter is unspecified, we use this metafunction
-    // to deduce the default types
-    template <class Dereferenceable>
-    struct default_indirect_value
-    {
-        typedef typename remove_cv<
-            typename referent<Dereferenceable>::type
-        >::type referent_t;
-
-        typedef typename mpl::if_<
-            mpl::or_<
-                class_has_element_type<Dereferenceable>
-              , iterator_is_mutable<Dereferenceable>
-            >
-          , referent_t
-          , referent_t const
-        >::type type;
-    };
-    
     template <class Iter, class Value, class Category, class Reference, class Difference>
     struct indirect_base
     {
@@ -156,10 +50,17 @@ namespace boost
             indirect_iterator<Iter, Value, Category, Reference, Difference>
           , Iter
           , typename ia_dflt_help<
-                Value, default_indirect_value<dereferenceable>
+                Value, pointee<dereferenceable>
             >::type
           , Category
-          , Reference
+          , typename ia_dflt_help<
+                Reference
+              , mpl::eval_if<
+                    is_same<Value,use_default>
+                  , indirect_reference<dereferenceable>
+                  , add_reference<Value>
+                >
+            >::type
           , Difference
         > type;
     };
@@ -168,19 +69,6 @@ namespace boost
     struct indirect_base<int, int, int, int, int> {};
   } // namespace detail
 
-  // User-specializable metafunction which returns the referent of a
-  // dereferenceable type.  The default implementation returns
-  // Dereferenceable::element_type if such a member exists (thus
-  // handling the boost smart pointers and auto_ptr), and
-  // iterator_traits<Dereferenceable>::value_type otherwise.
-  template <class Dereferenceable>
-  struct referent
-    : mpl::apply_if<
-          detail::class_has_element_type<Dereferenceable>
-        , detail::element_type<Dereferenceable>
-        , iterator_value<Dereferenceable>
-      >
-  {};
     
   template <
       class Iterator

include/boost/iterator/interoperable.hpp

@@ -1,11 +1,9 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 #ifndef BOOST_INTEROPERABLE_23022003THW_HPP
 # define BOOST_INTEROPERABLE_23022003THW_HPP
 

include/boost/iterator/iterator_adaptor.hpp

@@ -1,11 +1,9 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 #ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 
@@ -21,8 +19,6 @@
 #include <boost/mpl/not.hpp>
 #include <boost/mpl/or.hpp>
 
-#include <boost/python/detail/is_xxx.hpp>
-
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 
@@ -104,7 +100,22 @@ namespace boost
   // false positives for user/library defined iterator types. See comments
   // on operator implementation for consequences.
   //
-#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
+#  if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+  
+  template<typename From, typename To>
+  struct enable_if_convertible
+  {
+     typedef typename mpl::if_<
+         mpl::or_<
+             is_same<From,To>
+           , is_convertible<From, To>
+         >
+      , detail::enable_type
+      , int&
+     >::type type;
+  };
+  
+#  elif defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
   
   template <class From, class To>
   struct enable_if_convertible
@@ -148,7 +159,7 @@ namespace boost
     // DefaultNullaryFn, otherwise return T.
     template <class T, class DefaultNullaryFn>
     struct ia_dflt_help
-      : mpl::apply_if<
+      : mpl::eval_if<
             is_same<T, use_default>
           , DefaultNullaryFn
           , mpl::identity<T>
@@ -174,7 +185,7 @@ namespace boost
 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
           , typename detail::ia_dflt_help<
                 Value
-              , mpl::apply_if<
+              , mpl::eval_if<
                     is_same<Reference,use_default>
                   , iterator_value<Base>
                   , remove_reference<Reference>
@@ -193,7 +204,7 @@ namespace boost
 
           , typename detail::ia_dflt_help<
                 Reference
-              , mpl::apply_if<
+              , mpl::eval_if<
                     is_same<Value,use_default>
                   , iterator_reference<Base>
                   , add_reference<Value>
@@ -206,7 +217,13 @@ namespace boost
         >
         type;
     };
-    template <class T> int static_assert_convertible_to(T);
+  
+    // workaround for aC++ CR JAGaf33512
+    template <class Tr1, class Tr2>
+    inline void iterator_adaptor_assert_traversal ()
+    {
+      BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
+    }
   }
   
   //
@@ -249,22 +266,27 @@ namespace boost
   {
       friend class iterator_core_access;
 
+   protected:
       typedef typename detail::iterator_adaptor_base<
           Derived, Base, Value, Traversal, Reference, Difference
       >::type super_t;
-
    public:
       iterator_adaptor() {}
 
-      explicit iterator_adaptor(Base iter)
+      explicit iterator_adaptor(Base const &iter)
           : m_iterator(iter)
       {
       }
 
-      Base base() const
+      typedef Base base_type;
+
+      Base const& base() const
         { return m_iterator; }
 
    protected:
+      // for convenience in derived classes
+      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
+      
       //
       // lvalue access to the Base object for Derived
       //
@@ -301,8 +323,7 @@ namespace boost
       >::type my_traversal;
 
 # define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
-      typedef int assertion[sizeof(detail::static_assert_convertible_to<cat>(my_traversal()))];
-//      BOOST_STATIC_ASSERT((is_convertible<my_traversal,cat>::value));
+      detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
 
       void advance(typename super_t::difference_type n)
       {

include/boost/iterator/iterator_archetypes.hpp

@@ -1,8 +1,7 @@
-// (C) Copyright Jeremy Siek 2002. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// (C) Copyright Jeremy Siek 2002.
+// 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)
 
 #ifndef BOOST_ITERATOR_ARCHETYPES_HPP
 #define BOOST_ITERATOR_ARCHETYPES_HPP
@@ -19,12 +18,14 @@
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 
+#include <boost/concept_archetype.hpp>
+
 #include <boost/mpl/aux_/msvc_eti_base.hpp>
 #include <boost/mpl/bitand.hpp>
 #include <boost/mpl/int.hpp>
 #include <boost/mpl/equal_to.hpp>
 #include <boost/mpl/if.hpp>
-#include <boost/mpl/apply_if.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/identity.hpp>
 
@@ -80,26 +81,26 @@ namespace detail
   template <class T>
   struct assign_proxy
   {
-      assign_proxy& operator=(T);
+      assign_proxy& operator=(T) { return *this; }
   };
 
   template <class T>
   struct read_proxy
   {
-      operator T();
+      operator T() { return static_object<T>::get(); }
   };
 
   template <class T>
   struct read_write_proxy
-    : assign_proxy<T>
-    , read_proxy<T>
+    : read_proxy<T> // Use to inherit from assign_proxy, but that doesn't work. -JGS
   {
+      read_write_proxy& operator=(T) { return *this; }
   };
 
   template <class T>
   struct arrow_proxy
   {
-      T const* operator->() const;
+      T const* operator->() const { return 0; }
   };
 
   struct no_operator_brackets {};
@@ -107,21 +108,21 @@ namespace detail
   template <class ValueType>
   struct readable_operator_brackets
   {
-      read_proxy<ValueType> operator[](std::ptrdiff_t n) const;
+      read_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_proxy<ValueType>(); }
   };
 
   template <class ValueType>
   struct writable_operator_brackets
   {
-      read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const;
+      read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_write_proxy<ValueType>(); }
   };
 
   template <class Value, class AccessCategory, class TraversalCategory>
   struct operator_brackets
     : mpl::aux::msvc_eti_base<
-          typename mpl::apply_if<
+          typename mpl::eval_if<
               is_convertible<TraversalCategory, random_access_traversal_tag>
-            , mpl::apply_if<
+            , mpl::eval_if<
                   iterator_archetypes::has_access<
                       AccessCategory
                     , iterator_archetypes::writable_iterator_t
@@ -147,12 +148,26 @@ namespace detail
       template <class Derived,class Value> struct archetype;
   };
 
+  // Constructor argument for those iterators that
+  // are not default constructible
+  struct ctor_arg {};
+
   template <class Derived, class Value, class TraversalCategory>
   struct traversal_archetype_
     : mpl::aux::msvc_eti_base<
           typename traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
       >::type
-  {};
+  {
+      typedef typename
+        traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
+      base;
+      
+      traversal_archetype_() {}
+
+      traversal_archetype_(ctor_arg arg)
+        : base(arg) 
+      {}
+  };
 
   template <>
   struct traversal_archetype_impl<incrementable_traversal_tag>
@@ -160,10 +175,13 @@ namespace detail
       template<class Derived, class Value>
       struct archetype
       {
-          typedef void difference_type;
+          explicit archetype(ctor_arg) {}
 
-          Derived& operator++();
-          Derived  operator++(int) const;
+          struct bogus { }; // This use to be void, but that causes trouble for iterator_facade. Need more research. -JGS
+          typedef bogus difference_type;
+
+          Derived& operator++() { return (Derived&)static_object<Derived>::get(); }
+          Derived  operator++(int) const { return (Derived&)static_object<Derived>::get(); }
       };
   };
 
@@ -175,18 +193,21 @@ namespace detail
         : public equality_comparable< traversal_archetype_<Derived, Value, single_pass_traversal_tag> >,
           public traversal_archetype_<Derived, Value, incrementable_traversal_tag>
       {
+          explicit archetype(ctor_arg arg)
+            : traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg)
+          {}
       };
   };
 
   template <class Derived, class Value>
   bool operator==(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
-                  traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&);
+                  traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
   
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
   // doesn't seem to pick up != from equality_comparable
   template <class Derived, class Value>
   bool operator!=(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
-                  traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&);
+                  traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
 #endif 
   template <>
   struct traversal_archetype_impl<forward_traversal_tag>
@@ -195,6 +216,9 @@ namespace detail
       struct archetype
         : public traversal_archetype_<Derived, Value, single_pass_traversal_tag>
       {
+          archetype() 
+            : traversal_archetype_<Derived, Value, single_pass_traversal_tag>(ctor_arg())
+          {}
           typedef std::ptrdiff_t difference_type;
       };
   };
@@ -206,8 +230,8 @@ namespace detail
       struct archetype
         : public traversal_archetype_<Derived, Value, forward_traversal_tag>
       {
-          Derived& operator--();
-          Derived  operator--(int) const;
+          Derived& operator--() { return static_object<Derived>::get(); }
+          Derived  operator--(int) const { return static_object<Derived>::get(); }
       };
   };
 
@@ -216,33 +240,51 @@ namespace detail
   {
       template<class Derived, class Value>
       struct archetype
-        : public partially_ordered<traversal_archetype_<Derived, Value, random_access_traversal_tag> >,
-          public traversal_archetype_<Derived, Value, bidirectional_traversal_tag> 
+        : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag> 
       {
-          Derived& operator+=(std::ptrdiff_t);
-          Derived& operator-=(std::ptrdiff_t);
+          Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); }
+          Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); }
       };
   };
 
   template <class Derived, class Value>
   Derived& operator+(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-                     std::ptrdiff_t);
+                     std::ptrdiff_t) { return static_object<Derived>::get(); }
 
   template <class Derived, class Value>
   Derived& operator+(std::ptrdiff_t,
-                     traversal_archetype_<Derived, Value, random_access_traversal_tag> const&);
+                     traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+      { return static_object<Derived>::get(); }
 
   template <class Derived, class Value>
   Derived& operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-                     std::ptrdiff_t);
+                     std::ptrdiff_t)
+      { return static_object<Derived>::get(); }
 
   template <class Derived, class Value>
   std::ptrdiff_t operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-                           traversal_archetype_<Derived, Value, random_access_traversal_tag> const&);
+                           traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+      { return 0; }
 
   template <class Derived, class Value>
   bool operator<(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&);
+                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+      { return true; }
+
+  template <class Derived, class Value>
+  bool operator>(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+      { return true; }
+
+  template <class Derived, class Value>
+  bool operator<=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+      { return true; }
+
+  template <class Derived, class Value>
+  bool operator>=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
+                 traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
+      { return true; }
 
   struct bogus_type;
 
@@ -286,9 +328,9 @@ struct iterator_access_archetype_impl<
         typedef Value                           reference;
         typedef Value*                          pointer;
 
-        value_type operator*() const;
+        value_type operator*() const { return static_object<value_type>::get(); }
 
-        detail::arrow_proxy<Value> operator->() const;
+        detail::arrow_proxy<Value> operator->() const { return detail::arrow_proxy<Value>(); }
     };
 };
 
@@ -307,7 +349,7 @@ struct iterator_access_archetype_impl<
         typedef void reference;
         typedef void pointer;
 
-        detail::assign_proxy<Value> operator*() const;
+        detail::assign_proxy<Value> operator*() const { return detail::assign_proxy<Value>(); }
     };
 };
 
@@ -324,7 +366,7 @@ struct iterator_access_archetype_impl<
     {
         typedef detail::read_write_proxy<Value>    reference;
 
-        detail::read_write_proxy<Value> operator*() const;
+        detail::read_write_proxy<Value> operator*() const { return detail::read_write_proxy<Value>(); }
     };
 };
 
@@ -339,8 +381,8 @@ struct iterator_access_archetype_impl<iterator_archetypes::readable_lvalue_itera
     {
         typedef Value&    reference;
 
-        Value& operator*() const;
-        Value* operator->() const;
+        Value& operator*() const { return static_object<Value>::get(); }
+        Value* operator->() const { return 0; }
     };
 };
   
@@ -389,7 +431,7 @@ namespace detail
       
       typedef typename detail::facade_iterator_category<
           TraversalCategory
-        , typename mpl::apply_if<
+        , typename mpl::eval_if<
               iterator_archetypes::has_access<
                   AccessCategory, iterator_archetypes::writable_iterator_t
               >
@@ -443,13 +485,27 @@ struct iterator_archetype
     typedef typename base::iterator_category iterator_category;
 # endif
 
-    iterator_archetype();
-    iterator_archetype(iterator_archetype const&);
+    iterator_archetype() { }
+    iterator_archetype(iterator_archetype const& x)
+      : detail::iterator_archetype_base<
+            Value
+          , AccessCategory
+          , TraversalCategory
+        >(x)
+    {}
 
-    iterator_archetype& operator=(iterator_archetype const&);
+    iterator_archetype& operator=(iterator_archetype const&)
+        { return *this; }
 
+# if 0
     // Optional conversion from mutable
-    // iterator_archetype(iterator_archetype<typename detail::convertible_type<Value>::type, AccessCategory, TraversalCategory> const&);
+    iterator_archetype(
+        iterator_archetype<
+        typename detail::convertible_type<Value>::type
+      , AccessCategory
+      , TraversalCategory> const&
+    );
+# endif
 };
 
 } // namespace boost

include/boost/iterator/iterator_categories.hpp

@@ -1,8 +1,7 @@
-// (C) Copyright Jeremy Siek 2002. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// (C) Copyright Jeremy Siek 2002.
+// 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)
 
 #ifndef BOOST_ITERATOR_CATEGORIES_HPP
 # define BOOST_ITERATOR_CATEGORIES_HPP
@@ -13,7 +12,7 @@
 
 # include <boost/detail/workaround.hpp>
 
-# include <boost/mpl/apply_if.hpp>
+# include <boost/mpl/eval_if.hpp>
 # include <boost/mpl/identity.hpp>
 # include <boost/mpl/placeholders.hpp>
 # include <boost/mpl/aux_/lambda_support.hpp>
@@ -27,19 +26,43 @@ namespace boost {
 //
 // Traversal Categories
 //
-struct incrementable_traversal_tag {};
+
+struct no_traversal_tag {};
+
+struct incrementable_traversal_tag 
+  : no_traversal_tag
+{
+//     incrementable_traversal_tag() {}
+//     incrementable_traversal_tag(std::output_iterator_tag const&) {};
+};
   
 struct single_pass_traversal_tag
-  : incrementable_traversal_tag {};
+  : incrementable_traversal_tag
+{
+//     single_pass_traversal_tag() {}
+//     single_pass_traversal_tag(std::input_iterator_tag const&) {};
+};
   
 struct forward_traversal_tag
-  : single_pass_traversal_tag {};
+  : single_pass_traversal_tag
+{
+//     forward_traversal_tag() {}
+//     forward_traversal_tag(std::forward_iterator_tag const&) {};
+};
   
 struct bidirectional_traversal_tag
-  : forward_traversal_tag {};
+  : forward_traversal_tag
+{
+//     bidirectional_traversal_tag() {};
+//     bidirectional_traversal_tag(std::bidirectional_iterator_tag const&) {};
+};
   
 struct random_access_traversal_tag
-  : bidirectional_traversal_tag {};
+  : bidirectional_traversal_tag
+{
+//     random_access_traversal_tag() {};
+//     random_access_traversal_tag(std::random_access_iterator_tag const&) {};
+};
 
 namespace detail
 {  
@@ -51,19 +74,19 @@ namespace detail
   //
   template <class Cat>
   struct old_category_to_traversal
-    : mpl::apply_if<
+    : mpl::eval_if<
           is_convertible<Cat,std::random_access_iterator_tag>
         , mpl::identity<random_access_traversal_tag>
-        , mpl::apply_if<
+        , mpl::eval_if<
               is_convertible<Cat,std::bidirectional_iterator_tag>
             , mpl::identity<bidirectional_traversal_tag>
-            , mpl::apply_if<
+            , mpl::eval_if<
                   is_convertible<Cat,std::forward_iterator_tag>
                 , mpl::identity<forward_traversal_tag>
-                , mpl::apply_if<
+                , mpl::eval_if<
                       is_convertible<Cat,std::input_iterator_tag>
                     , mpl::identity<single_pass_traversal_tag>
-                    , mpl::apply_if<
+                    , mpl::eval_if<
                           is_convertible<Cat,std::output_iterator_tag>
                         , mpl::identity<incrementable_traversal_tag>
                         , void
@@ -74,7 +97,7 @@ namespace detail
       >
   {};
 
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
   template <>
   struct old_category_to_traversal<int>
   {
@@ -84,19 +107,19 @@ namespace detail
 
   template <class Traversal>
   struct pure_traversal_tag
-    : mpl::apply_if<
+    : mpl::eval_if<
           is_convertible<Traversal,random_access_traversal_tag>
         , mpl::identity<random_access_traversal_tag>
-        , mpl::apply_if<
+        , mpl::eval_if<
               is_convertible<Traversal,bidirectional_traversal_tag>
             , mpl::identity<bidirectional_traversal_tag>
-            , mpl::apply_if<
+            , mpl::eval_if<
                   is_convertible<Traversal,forward_traversal_tag>
                 , mpl::identity<forward_traversal_tag>
-                , mpl::apply_if<
+                , mpl::eval_if<
                       is_convertible<Traversal,single_pass_traversal_tag>
                     , mpl::identity<single_pass_traversal_tag>
-                    , mpl::apply_if<
+                    , mpl::eval_if<
                           is_convertible<Traversal,incrementable_traversal_tag>
                         , mpl::identity<incrementable_traversal_tag>
                         , void
@@ -108,7 +131,7 @@ namespace detail
   {
   };
   
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
   template <>
   struct pure_traversal_tag<int>
   {
@@ -124,7 +147,7 @@ namespace detail
 //
 template <class Cat>
 struct iterator_category_to_traversal
-  : mpl::apply_if< // if already convertible to a traversal tag, we're done.
+  : mpl::eval_if< // if already convertible to a traversal tag, we're done.
         is_convertible<Cat,incrementable_traversal_tag>
       , mpl::identity<Cat>
       , detail::old_category_to_traversal<Cat>
@@ -139,7 +162,7 @@ struct iterator_traversal
     >
 {};
 
-# ifdef BOOST_MPL_NO_FULL_LAMBDA_SUPPORT
+# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
 // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
 // out well.  Instantiating the nested apply template also
 // requires instantiating iterator_traits on the

include/boost/iterator/iterator_concepts.hpp

@@ -1,8 +1,7 @@
-// (C) Copyright Jeremy Siek 2002. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// (C) Copyright Jeremy Siek 2002.
+// 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)
 
 #ifndef BOOST_ITERATOR_CONCEPTS_HPP
 #define BOOST_ITERATOR_CONCEPTS_HPP
@@ -32,6 +31,7 @@
 
 // Use boost/limits to work around missing limits headers on some compilers
 #include <boost/limits.hpp>
+#include <boost/config.hpp>
 
 #include <algorithm>
 
@@ -60,19 +60,13 @@ namespace boost_concepts {
   class ReadableIteratorConcept {
   public:
     typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type;
-    typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference reference;
 
     void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
-      boost::function_requires< 
-        boost::DefaultConstructibleConcept<Iterator> >();
+      boost::function_requires< boost::AssignableConcept<Iterator> >();
+      boost::function_requires< boost::CopyConstructibleConcept<Iterator> >();
 
-      reference r = *i; // or perhaps read(x)
-      value_type v = r;
-      value_type v2 = *i;
+      value_type v = *i;
       boost::ignore_unused_variable_warning(v);
-      boost::ignore_unused_variable_warning(v2);
     }
     Iterator i;
   };
@@ -85,12 +79,8 @@ namespace boost_concepts {
   public:
       
     void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
-      boost::function_requires< 
-        boost::DefaultConstructibleConcept<Iterator> >();
-      
-      *i = v; // a good alternative could be something like write(x, v)
+      boost::function_requires< boost::CopyConstructibleConcept<Iterator> >();
+      *i = v;
     }
     ValueType v;
     Iterator i;
@@ -108,47 +98,18 @@ namespace boost_concepts {
   };
 
   template <typename Iterator>
-  class ReadableLvalueIteratorConcept
+  class LvalueIteratorConcept
   {
    public:
       typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
-      typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
-
       void constraints()
       {
-          boost::function_requires< ReadableIteratorConcept<Iterator> >();
-
-          typedef boost::mpl::or_<
-              boost::is_same<reference, value_type&>
-            , boost::is_same<reference, value_type const&>
-          > correct_reference;
-        
-          BOOST_STATIC_ASSERT(correct_reference::value);
-
-          reference v = *i;
-          boost::ignore_unused_variable_warning(v);
-    }
+        value_type& r = const_cast<value_type&>(*i);
+        boost::ignore_unused_variable_warning(r);
+      }
     Iterator i;
   };
 
-  template <typename Iterator>
-  class WritableLvalueIteratorConcept {
-  public:
-    typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
-
-    void constraints() {
-      boost::function_requires< 
-        ReadableLvalueIteratorConcept<Iterator> >();
-      boost::function_requires< 
-        WritableIteratorConcept<Iterator, value_type> >();
-      boost::function_requires< 
-        SwappableIteratorConcept<Iterator> >();
-      
-
-      BOOST_STATIC_ASSERT((boost::is_same<reference, value_type&>::value));
-    }
-  };
   
   //===========================================================================
   // Iterator Traversal Concepts
@@ -159,9 +120,8 @@ namespace boost_concepts {
     typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
 
     void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< 
-        boost::DefaultConstructibleConcept<Iterator> >();
+      boost::function_requires< boost::AssignableConcept<Iterator> >();
+      boost::function_requires< boost::CopyConstructibleConcept<Iterator> >();
 
       BOOST_STATIC_ASSERT(
           (boost::is_convertible<
@@ -203,6 +163,8 @@ namespace boost_concepts {
 
     void constraints() {
       boost::function_requires< SinglePassIteratorConcept<Iterator> >();
+      boost::function_requires< 
+        boost::DefaultConstructibleConcept<Iterator> >();
 
       typedef boost::mpl::and_<
         boost::is_integral<difference_type>,
@@ -271,109 +233,73 @@ namespace boost_concepts {
   //===========================================================================
   // Iterator Interoperability Concept
 
-namespace detail
-{
-
-  template <typename TraversalTag>
-  struct Operations;
-    
-  template <>
-  struct Operations<boost::incrementable_traversal_tag>
+  namespace detail
   {
-      template <typename Iterator1, typename Iterator2>
-      static void constraints(Iterator1 const& i1, Iterator2 const& i2)
-      {
-          // no interoperability constraints
-      }
-  };
 
-  template <>
-  struct Operations<boost::single_pass_traversal_tag>
-  {
-      template <typename Iterator1, typename Iterator2>
-      static void constraints(Iterator1 const& i1, Iterator2 const& i2)
-      {
-          Operations<boost::incrementable_traversal_tag>::constraints(i1, i2);
-          i1 == i2;
-          i1 != i2;
-
-          i2 == i1;
-          i2 != i1;
-      }
-  };
-
-  template <>
-  struct Operations<boost::forward_traversal_tag>
-  {
-      template <typename Iterator1, typename Iterator2>
-      static void constraints(Iterator1 const& i1, Iterator2 const& i2)
-      {
-          Operations<boost::single_pass_traversal_tag>::constraints(i1, i2);
-      }
-  };
-
-  template <>
-  struct Operations<boost::bidirectional_traversal_tag>
-  {
-      template <typename Iterator1, typename Iterator2>
-      static void constraints(Iterator1 const& i1, Iterator2 const& i2)
-      {
-          Operations<boost::forward_traversal_tag>::constraints(i1, i2);
-      }
-  };
-
-    template <>
-    struct Operations<boost::random_access_traversal_tag>
+    template <typename Iterator1, typename Iterator2>
+    void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
     {
-      template <typename Iterator1, typename Iterator2>
-      static void constraints(Iterator1 const& i1, Iterator2 const& i2)
-      {
-        Operations<boost::bidirectional_traversal_tag>::constraints(i1, i2);
-
-        i1 <  i2;
-        i1 <= i2;
-        i1 >  i2;
-        i1 >= i2;
-        i1 -  i2;
-
-        i2 <  i1;
-        i2 <= i1;
-        i2 >  i1;
-        i2 >= i1;
-        i2 -  i1;
-      }
-    };
+      bool b;
+      b = i1 == i2;
+      b = i1 != i2;
+      
+      b = i2 == i1;
+      b = i2 != i1;
+    }
+    
+    template <typename Iterator1, typename Iterator2>
+    void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2,
+                                         boost::random_access_traversal_tag, boost::random_access_traversal_tag)
+    {
+      bool b;
+      typename boost::detail::iterator_traits<Iterator2>::difference_type n;
+      b = i1 <  i2;
+      b = i1 <= i2;
+      b = i1 >  i2;
+      b = i1 >= i2;
+      n = i1 -  i2;
+      
+      b = i2 <  i1;
+      b = i2 <= i1;
+      b = i2 >  i1;
+      b = i2 >= i1;
+      n = i2 -  i1;
+    }
+    template <typename Iterator1, typename Iterator2>
+    void interop_rand_access_constraints(Iterator1 const& i1, Iterator2 const& i2,
+                                         boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
+    { }
 
   } // namespace detail
 
   template <typename Iterator, typename ConstIterator>
-  class InteroperableConcept
+  class InteroperableIteratorConcept
   {
   public:
-    typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type
-      difference_type;
+      typedef typename boost::detail::pure_traversal_tag<
+          typename boost::iterator_traversal<
+              Iterator
+          >::type
+      >::type traversal_category;
 
-    typedef typename boost::iterator_traversal<ConstIterator>::type
-      const_traversal_category;
-    typedef typename boost::detail::iterator_traits<ConstIterator>::difference_type
-      const_difference_type;
+      typedef typename boost::detail::pure_traversal_tag<
+          typename boost::iterator_traversal<
+              ConstIterator
+          >::type
+      >::type const_traversal_category;
 
-    void constraints() {
-      BOOST_STATIC_ASSERT((boost::is_same< difference_type,
-                                           const_difference_type>::value));
-      BOOST_STATIC_ASSERT((boost::is_same< traversal_category,
-                                           const_traversal_category>::value));
-      
-      // ToDo check what the std really requires
-      
-      // detail::Operations<traversal_category>::constraints(i, ci);
+      void constraints()
+      {
+          boost::function_requires< SinglePassIteratorConcept<Iterator> >();
+          boost::function_requires< SinglePassIteratorConcept<ConstIterator> >();
 
-      ci = i;
+          detail::interop_single_pass_constraints(i, ci);
+          detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
 
-    }
-    Iterator      i;
-    ConstIterator ci;
+          ci = i;
+      }
+      Iterator      i;
+      ConstIterator ci;
   };
 
 } // namespace boost_concepts

include/boost/iterator/iterator_facade.hpp

@@ -1,30 +1,38 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 #ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP
 #define BOOST_ITERATOR_FACADE_23022003THW_HPP
 
-#include <boost/static_assert.hpp>
-
 #include <boost/iterator.hpp>
 #include <boost/iterator/interoperable.hpp>
+#include <boost/iterator/iterator_traits.hpp>
 
 #include <boost/iterator/detail/facade_iterator_category.hpp>
 #include <boost/iterator/detail/enable_if.hpp>
 
+#include <boost/implicit_cast.hpp>
+#include <boost/static_assert.hpp>
+
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_pointer.hpp>
 #include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_pod.hpp>
 
-#include <boost/mpl/apply_if.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
 #include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/identity.hpp>
 
 #include <boost/iterator/detail/config_def.hpp> // this goes last
 
@@ -36,19 +44,39 @@ namespace boost
 
   namespace detail
   {
+    // A binary metafunction class that always returns bool.  VC6
+    // ICEs on mpl::always<bool>, probably because of the default
+    // parameters.
+    struct always_bool2
+    {
+        template <class T, class U>
+        struct apply
+        {
+            typedef bool type;
+        };
+    };
+
     //
     // enable if for use in operator implementation.
     //
-    // enable_if_interoperable falls back to always enabled for compilers
-    // that don't support enable_if or is_convertible.
-    //
     template <
         class Facade1
       , class Facade2
       , class Return
     >
     struct enable_if_interoperable
-#ifndef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    {
+        typedef typename mpl::if_<
+            mpl::or_<
+                is_convertible<Facade1, Facade2>
+              , is_convertible<Facade2, Facade1>
+            >
+          , Return
+          , int[3]
+        >::type type;
+    };        
+#else
       : ::boost::iterators::enable_if<
            mpl::or_<
                is_convertible<Facade1, Facade2>
@@ -56,12 +84,8 @@ namespace boost
            >
          , Return
         >
-#endif
-    {
-#ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-        typedef Return type;
-#endif
-    };
+    {};
+#endif 
 
     //
     // Generates associated types for an iterator_facade with the
@@ -81,9 +105,9 @@ namespace boost
         
         typedef typename remove_const<ValueParam>::type value_type;
         
-        typedef typename mpl::apply_if<
+        typedef typename mpl::eval_if<
             detail::iterator_writability_disabled<ValueParam,Reference>
-          , add_pointer<typename add_const<value_type>::type>
+          , add_pointer<const value_type>
           , add_pointer<value_type>
         >::type pointer;
       
@@ -105,12 +129,172 @@ namespace boost
 # endif
     };
 
+    // iterators whose dereference operators reference the same value
+    // for all iterators into the same sequence (like many input
+    // iterators) need help with their postfix ++: the referenced
+    // value must be read and stored away before the increment occurs
+    // so that *a++ yields the originally referenced element and not
+    // the next one.
+    template <class Iterator>
+    class postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+        {}
+
+        // Returning a mutable reference allows nonsense like
+        // (*r++).mutate(), but it imposes fewer assumptions about the
+        // behavior of the value_type.  In particular, recall taht
+        // (*r).mutate() is legal if operator* returns by value.
+        value_type&
+        operator*() const
+        {
+            return this->stored_value;
+        }
+     private:
+        mutable value_type stored_value;
+    };
+    
+    //
+    // In general, we can't determine that such an iterator isn't
+    // writable -- we also need to store a copy of the old iterator so
+    // that it can be written into.
+    template <class Iterator>
+    class writable_postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit writable_postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+          , stored_iterator(x)
+        {}
+
+        // Dereferencing must return a proxy so that both *r++ = o and
+        // value_type(*r++) can work.  In this case, *r is the same as
+        // *r++, and the conversion operator below is used to ensure
+        // readability.
+        writable_postfix_increment_proxy const&
+        operator*() const
+        {
+            return *this;
+        }
+
+        // Provides readability of *r++
+        operator value_type&() const
+        {
+            return stored_value;
+        }
+
+        // Provides writability of *r++
+        template <class T>
+        T const& operator=(T const& x) const
+        {
+            *this->stored_iterator = x;
+            return x;
+        }
+
+        // This overload just in case only non-const objects are writable
+        template <class T>
+        T& operator=(T& x) const
+        {
+            *this->stored_iterator = x;
+            return x;
+        }
+
+        // Provides X(r++)
+        operator Iterator const&() const
+        {
+            return stored_iterator;
+        }
+        
+     private:
+        mutable value_type stored_value;
+        Iterator stored_iterator;
+    };
+
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+    template <class Reference, class Value>
+    struct is_non_proxy_reference_impl
+    {
+        static Reference r;
+        
+        template <class R>
+        static typename mpl::if_<
+            is_convertible<
+                R const volatile*
+              , Value const volatile*
+            >
+          , char[1]
+          , char[2]
+        >::type& helper(R const&);
+        
+        BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1);
+    };
+        
+    template <class Reference, class Value>
+    struct is_non_proxy_reference
+      : mpl::bool_<
+            is_non_proxy_reference_impl<Reference, Value>::value
+        >
+    {};
+# else 
+    template <class Reference, class Value>
+    struct is_non_proxy_reference
+      : is_convertible<
+            typename remove_reference<Reference>::type
+            const volatile*
+          , Value const volatile*
+        >
+    {};
+# endif 
+        
+    // A metafunction to choose the result type of postfix ++
+    //
+    // Because the C++98 input iterator requirements say that *r++ has
+    // type T (value_type), implementations of some standard
+    // algorithms like lexicographical_compare may use constructions
+    // like:
+    //
+    //          *r++ < *s++
+    //
+    // If *r++ returns a proxy (as required if r is writable but not
+    // multipass), this sort of expression will fail unless the proxy
+    // supports the operator<.  Since there are any number of such
+    // operations, we're not going to try to support them.  Therefore,
+    // even if r++ returns a proxy, *r++ will only return a proxy if
+    // *r also returns a proxy.
+    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
+    struct postfix_increment_result
+      : mpl::eval_if<
+            mpl::and_<
+                // A proxy is only needed for readable iterators
+                is_convertible<Reference,Value const&>
+                
+                // No multipass iterator can have values that disappear
+                // before positions can be re-visited
+              , mpl::not_<
+                    is_convertible<
+                        typename iterator_category_to_traversal<CategoryOrTraversal>::type
+                      , forward_traversal_tag
+                    >
+                >
+            >
+          , mpl::if_<
+                is_non_proxy_reference<Reference,Value>
+              , postfix_increment_proxy<Iterator>
+              , writable_postfix_increment_proxy<Iterator>
+            >
+          , mpl::identity<Iterator>
+        >
+    {};
 
     // operator->() needs special support for input iterators to strictly meet the
     // standard's requirements. If *i is not a reference type, we must still
     // produce a (constant) lvalue to which a pointer can be formed. We do that by
     // returning an instantiation of this special proxy class template.
-
     template <class T>
     struct operator_arrow_proxy
     {
@@ -125,7 +309,7 @@ namespace boost
     // A metafunction that gets the result type for operator->.  Also
     // has a static function make() which builds the result from a
     // Reference
-    template <class Value, class Reference, class Pointer>
+    template <class ValueType, class Reference, class Pointer>
     struct operator_arrow_result
     {
         // CWPro8.3 won't accept "operator_arrow_result::type", and we
@@ -134,16 +318,16 @@ namespace boost
         typedef typename mpl::if_<
             is_reference<Reference>
           , Pointer
-          , operator_arrow_proxy<Value>
+          , operator_arrow_proxy<ValueType>
         >::type type;
 
         static type make(Reference x)
         {
-            return type(&x);
+            return implicit_cast<type>(&x);
         }
     };
 
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
     // Deal with ETI
     template<>
     struct operator_arrow_result<int, int, int>
@@ -152,13 +336,14 @@ namespace boost
     };
 # endif
 
-    //
-    // Iterator is actually an iterator_facade, so we do not have to
-    // go through iterator_traits to access the traits.
-    //
+    // A proxy return type for operator[], needed to deal with
+    // iterators that may invalidate referents upon destruction.
+    // Consider the temporary iterator in *(a + n)
     template <class Iterator>
     class operator_brackets_proxy
     {
+        // Iterator is actually an iterator_facade, so we do not have to
+        // go through iterator_traits to access the traits.
         typedef typename Iterator::reference  reference;
         typedef typename Iterator::value_type value_type;
 
@@ -182,43 +367,93 @@ namespace boost
         Iterator m_iter;
     };
 
+    // A metafunction that determines whether operator[] must return a
+    // proxy, or whether it can simply return a copy of the value_type.
+    template <class ValueType, class Reference>
+    struct use_operator_brackets_proxy
+      : mpl::not_<
+            mpl::and_<
+                // Really we want an is_copy_constructible trait here,
+                // but is_POD will have to suffice in the meantime.
+                boost::is_POD<ValueType>
+              , iterator_writability_disabled<ValueType,Reference>
+            >
+        >
+    {};
+        
     template <class Iterator, class Value, class Reference>
     struct operator_brackets_result
     {
         typedef typename mpl::if_<
-            iterator_writability_disabled<Value,Reference>
-          , Value 
+            use_operator_brackets_proxy<Value,Reference>
           , operator_brackets_proxy<Iterator>
+          , Value
         >::type type;
     };
 
     template <class Iterator>
-    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::false_)
+    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
     {
         return operator_brackets_proxy<Iterator>(iter);
     }
 
     template <class Iterator>
-    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::true_)
+    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
     {
       return *iter;
     }
 
+    struct choose_difference_type
+    {
+        template <class I1, class I2>
+        struct apply
+          :
+# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+          iterator_difference<I1>
+# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+          mpl::if_<
+              is_convertible<I2,I1>
+            , typename I1::difference_type
+            , typename I2::difference_type
+          >
+# else 
+          mpl::eval_if<
+              is_convertible<I2,I1>
+            , iterator_difference<I1>
+            , iterator_difference<I2>
+          >
+# endif 
+        {};
+
+    };
   } // namespace detail
 
 
   // Macros which describe the declarations of binary operators
+# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)   \
+    template <                                                          \
+        class Derived1, class V1, class TC1, class R1, class D1         \
+      , class Derived2, class V2, class TC2, class R2, class D2         \
+    >                                                                   \
+    prefix typename mpl::apply2<result_type,Derived1,Derived2>::type    \
+    operator op(                                                        \
+        iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs           \
+      , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)
+# else 
 #  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)   \
     template <                                                          \
         class Derived1, class V1, class TC1, class R1, class D1         \
       , class Derived2, class V2, class TC2, class R2, class D2         \
     >                                                                   \
     prefix typename detail::enable_if_interoperable<                    \
-        Derived1, Derived2, result_type                                 \
+        Derived1, Derived2                                              \
+      , typename mpl::apply2<result_type,Derived1,Derived2>::type       \
     >::type                                                             \
     operator op(                                                        \
         iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs           \
       , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)
+# endif 
 
 #  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
     template <class Derived, class V, class TC, class R, class D>   \
@@ -244,8 +479,8 @@ namespace boost
       
       template <class I, class V, class TC, class R, class D> friend class iterator_facade;
 
-#  define BOOST_ITERATOR_FACADE_RELATION(op)     \
-      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, bool);
+#  define BOOST_ITERATOR_FACADE_RELATION(op)                                \
+      BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, detail::always_bool2);
 
       BOOST_ITERATOR_FACADE_RELATION(==)
       BOOST_ITERATOR_FACADE_RELATION(!=)
@@ -257,7 +492,7 @@ namespace boost
 #  undef BOOST_ITERATOR_FACADE_RELATION
 
       BOOST_ITERATOR_FACADE_INTEROP_HEAD(
-          friend, -, typename Derived1::difference_type)
+          friend, -, detail::choose_difference_type)
       ;
 
       BOOST_ITERATOR_FACADE_PLUS_HEAD(
@@ -295,11 +530,17 @@ namespace boost
       }
 
       template <class Facade1, class Facade2>
-      static bool equal(Facade1 const& f1, Facade2 const& f2)
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
       {
           return f1.equal(f2);
       }
 
+      template <class Facade1, class Facade2>
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.equal(f1);
+      }
+
       template <class Facade>
       static void advance(Facade& f, typename Facade::difference_type n)
       {
@@ -307,10 +548,32 @@ namespace boost
       }
 
       template <class Facade1, class Facade2>
-      static typename Facade1::difference_type distance_to(
-                                                           Facade1 const& f1, Facade2 const& f2)
+      static typename Facade1::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::true_)
       {
-          return f1.distance_to(f2);
+          return -f1.distance_to(f2);
+      }
+
+      template <class Facade1, class Facade2>
+      static typename Facade2::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.distance_to(f1);
+      }
+
+      //
+      // Curiously Recurring Template interface.
+      //
+      template <class I, class V, class TC, class R, class D>
+      static I& derived(iterator_facade<I,V,TC,R,D>& facade)
+      {
+          return *static_cast<I*>(&facade);
+      }
+
+      template <class I, class V, class TC, class R, class D>
+      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
+      {
+          return *static_cast<I const*>(&facade);
       }
 
    private:
@@ -341,21 +604,23 @@ namespace boost
       //
       // Curiously Recurring Template interface.
       //
-      typedef Derived derived_t;
-
       Derived& derived()
       {
-          return static_cast<Derived&>(*this);
+          return *static_cast<Derived*>(this);
       }
 
       Derived const& derived() const
       {
-          return static_cast<Derived const&>(*this);
+          return *static_cast<Derived const*>(this);
       }
 
       typedef detail::iterator_facade_types<
          Value, CategoryOrTraversal, Reference, Difference
       > associated_types;
+
+   protected:
+      // For use by derived classes
+      typedef iterator_facade<Derived,Value,Reference,Difference> iterator_facade_;
       
    public:
 
@@ -384,15 +649,14 @@ namespace boost
           >::make(*this->derived());
       }
         
-      typename detail::operator_brackets_result<Derived,Value,Reference>::type
+      typename detail::operator_brackets_result<Derived,Value,reference>::type
       operator[](difference_type n) const
       {
-          typedef detail::iterator_writability_disabled<Value,Reference>
-              not_writable;
+          typedef detail::use_operator_brackets_proxy<Value,Reference> use_proxy;
           
           return detail::make_operator_brackets_result<Derived>(
               this->derived() + n
-            , not_writable()
+            , use_proxy()
           );
       }
 
@@ -402,13 +666,17 @@ namespace boost
           return this->derived();
       }
 
-      Derived operator++(int)
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+      typename detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type
+      operator++(int)
       {
-          Derived tmp(this->derived());
+          typename detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type
+          tmp(this->derived());
           ++*this;
           return tmp;
       }
-
+# endif
+      
       Derived& operator--()
       {
           iterator_core_access::decrement(this->derived());
@@ -440,7 +708,7 @@ namespace boost
           return result -= x;
       }
 
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
       // There appears to be a bug which trashes the data of classes
       // derived from iterator_facade when they are assigned unless we
       // define this assignment operator.  This bug is only revealed
@@ -453,8 +721,26 @@ namespace boost
 # endif
   };
 
+# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+  template <class I, class V, class TC, class R, class D>
+  typename detail::postfix_increment_result<I,V,R,TC>::type
+  operator++(
+      iterator_facade<I,V,TC,R,D>& i
+    , int
+  )
+  {
+      typename detail::postfix_increment_result<I,V,R,TC>::type
+          tmp(*static_cast<I*>(&i));
+      
+      ++i;
+      
+      return tmp;
+  }
+# endif 
+
+  
   //
-  // Operator implementation. The library supplied operators
+  // Comparison operator implementation. The library supplied operators
   // enables the user to provide fully interoperable constant/mutable
   // iterator types. I.e. the library provides all operators
   // for all mutable/constant iterator combinations.
@@ -520,23 +806,30 @@ namespace boost
   // ----------------
   //
 
-# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, condition, return_prefix, base_op)  \
-  BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type)                               \
-  {                                                                                         \
-      /* For those compilers that do not support enable_if */                               \
-      BOOST_STATIC_ASSERT((                                                                 \
-          is_interoperable< Derived1, Derived2 >::value                                     \
-          && condition                                                                      \
-      ));                                                                                   \
-      return_prefix iterator_core_access::base_op(                                          \
-          static_cast<Derived2 const&>(rhs), static_cast<Derived1 const&>(lhs));            \
+# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+#  define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_()
+# else
+#  define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()
+# endif
+
+# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \
+  BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type)                   \
+  {                                                                             \
+      /* For those compilers that do not support enable_if */                   \
+      BOOST_STATIC_ASSERT((                                                     \
+          is_interoperable< Derived1, Derived2 >::value                         \
+      ));                                                                       \
+      return_prefix iterator_core_access::base_op(                              \
+          *static_cast<Derived1 const*>(&lhs)                                   \
+        , *static_cast<Derived2 const*>(&rhs)                                   \
+        , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1)                         \
+      );                                                                        \
   }
 
 # define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
   BOOST_ITERATOR_FACADE_INTEROP(                                    \
       op                                                            \
-    , bool                                                          \
-    , true                                                          \
+    , detail::always_bool2                                          \
     , return_prefix                                                 \
     , base_op                                                       \
   )
@@ -544,22 +837,19 @@ namespace boost
   BOOST_ITERATOR_FACADE_RELATION(==, return, equal)
   BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal)
 
-  BOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_to)
-  BOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_to)
-  BOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_to)
-  BOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_to)
+  BOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_from)
+  BOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_from)
+  BOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_from)
+  BOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_from)
 # undef BOOST_ITERATOR_FACADE_RELATION
 
   // operator- requires an additional part in the static assertion
   BOOST_ITERATOR_FACADE_INTEROP(
       -
-    , typename Derived1::difference_type
-    , (is_same<
-           BOOST_DEDUCED_TYPENAME Derived1::difference_type
-         , BOOST_DEDUCED_TYPENAME Derived2::difference_type
-       >::value)
+    , detail::choose_difference_type
     , return
-    , distance_to )
+    , distance_from
+  )
 # undef BOOST_ITERATOR_FACADE_INTEROP
 # undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
 

include/boost/iterator/iterator_traits.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams 2003. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// Copyright David Abrahams 2003.
+// 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)
 #ifndef ITERATOR_TRAITS_DWA200347_HPP
 # define ITERATOR_TRAITS_DWA200347_HPP
 
@@ -56,7 +55,7 @@ struct BOOST_ITERATOR_CATEGORY
     typedef typename detail::iterator_traits<Iterator>::iterator_category type;
 };
 
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 template <>
 struct iterator_value<int>
 {

include/boost/iterator/new_iterator_tests.hpp

@@ -1,6 +1,17 @@
 #ifndef BOOST_NEW_ITERATOR_TESTS_HPP
 # define BOOST_NEW_ITERATOR_TESTS_HPP
 
+//
+// Copyright (c) David Abrahams 2001.
+// Copyright (c) Jeremy Siek 2001-2003.
+// Copyright (c) Thomas Witt 2002.
+//
+// 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)
+//
+
 // This is meant to be the beginnings of a comprehensive, generic
 // test suite for STL concepts such as iterators and containers.
 //
@@ -28,9 +39,38 @@
 # include <boost/iterator/is_lvalue_iterator.hpp>
 
 # include <boost/iterator/detail/config_def.hpp>
+# include <boost/detail/is_incrementable.hpp>
 
 namespace boost {
 
+
+// Do separate tests for *i++ so we can treat, e.g., smart pointers,
+// as readable and/or writable iterators.
+template <class Iterator, class T>
+void readable_iterator_traversal_test(Iterator i1, T v, mpl::true_)
+{
+    T v2(*i1++);
+    assert(v == v2);
+}
+
+template <class Iterator, class T>
+void readable_iterator_traversal_test(const Iterator i1, T v, mpl::false_)
+{}
+
+template <class Iterator, class T>
+void writable_iterator_traversal_test(Iterator i1, T v, mpl::true_)
+{
+    ++i1;  // we just wrote into that position
+    *i1++ = v;
+    Iterator x(i1++);
+    (void)x;
+}
+
+template <class Iterator, class T>
+void writable_iterator_traversal_test(const Iterator i1, T v, mpl::false_)
+{}
+
+
 // Preconditions: *i == v
 template <class Iterator, class T>
 void readable_iterator_test(const Iterator i1, T v)
@@ -45,6 +85,8 @@ void readable_iterator_test(const Iterator i1, T v)
   assert(v2 == v);
 
 # if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+  readable_iterator_traversal_test(i1, v, detail::is_postfix_incrementable<Iterator>());
+      
   // I think we don't really need this as it checks the same things as
   // the above code.
   BOOST_STATIC_ASSERT(is_readable_iterator<Iterator>::value);
@@ -52,10 +94,18 @@ void readable_iterator_test(const Iterator i1, T v)
 }
 
 template <class Iterator, class T>
-void writable_iterator_test(Iterator i, T v)
+void writable_iterator_test(Iterator i, T v, T v2)
 {
   Iterator i2(i); // Copy Constructible
   *i2 = v;
+
+# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+  writable_iterator_traversal_test(
+      i, v2, mpl::and_<
+          detail::is_incrementable<Iterator>
+        , detail::is_postfix_incrementable<Iterator>
+      >());
+# endif 
 }
 
 template <class Iterator>

include/boost/iterator/permutation_iterator.hpp

@@ -1,10 +1,9 @@
 // (C) Copyright Toon Knapen    2001.
 // (C) Copyright David Abrahams 2003.
 // (C) Copyright Roland Richter 2003.
-// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies.
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
+// 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)
 
 #ifndef BOOST_PERMUTATION_ITERATOR_HPP
 #define BOOST_PERMUTATION_ITERATOR_HPP
@@ -18,64 +17,40 @@ namespace boost
 {
 
 template< class ElementIterator
-        , class IndexIterator
-        , class ValueT        = use_default
-        , class CategoryT     = use_default
-        , class ReferenceT    = use_default
-        , class DifferenceT   = use_default >
+        , class IndexIterator>
 class permutation_iterator
   : public iterator_adaptor< 
-             permutation_iterator<ElementIterator, IndexIterator, ValueT, CategoryT, ReferenceT, DifferenceT>
-           , ElementIterator, ValueT, CategoryT, ReferenceT, DifferenceT >
+             permutation_iterator<ElementIterator, IndexIterator>
+           , IndexIterator, typename detail::iterator_traits<ElementIterator>::value_type
+           , use_default, typename detail::iterator_traits<ElementIterator>::reference>
 {
   typedef iterator_adaptor< 
-            permutation_iterator<ElementIterator, IndexIterator, ValueT, CategoryT, ReferenceT, DifferenceT>
-          , ElementIterator, ValueT, CategoryT, ReferenceT, DifferenceT > super_t;
+            permutation_iterator<ElementIterator, IndexIterator>
+          , IndexIterator, typename detail::iterator_traits<ElementIterator>::value_type
+          , use_default, typename detail::iterator_traits<ElementIterator>::reference> super_t;
 
   friend class iterator_core_access;
 
 public:
-  permutation_iterator() : order_it_() {}
+  permutation_iterator() : m_elt_iter() {}
 
   explicit permutation_iterator(ElementIterator x, IndexIterator y) 
-      : super_t(x), order_it_(y) {}
+      : super_t(y), m_elt_iter(x) {}
 
-  template<class OtherElementIterator, class OtherIndexIterator, class V, class C, class R, class D >
+  template<class OtherElementIterator, class OtherIndexIterator>
   permutation_iterator(
-      permutation_iterator<OtherElementIterator, OtherIndexIterator, V, C, R, D> const& r
+      permutation_iterator<OtherElementIterator, OtherIndexIterator> const& r
       , typename enable_if_convertible<OtherElementIterator, ElementIterator>::type* = 0
       , typename enable_if_convertible<OtherIndexIterator, IndexIterator>::type* = 0
       )
-      : super_t(r.base())
+    : super_t(r.base()), m_elt_iter(r.m_elt_iter)
   {}
 
 private:
     typename super_t::reference dereference() const
-        { return *(this->base() + *this->order_it_); }
-  
-    void increment() { ++this->order_it_; }
-    void decrement() { --this->order_it_; }
+        { return *(m_elt_iter + *this->base()); }
 
-    void advance(typename super_t::difference_type n)
-    {
-      std::advance( order_it_, n );
-    }
-
-    template<class OtherElementIterator, class OtherIndexIterator, class V, class C, class R, class D >
-    typename super_t::difference_type
-    distance_to( permutation_iterator<OtherElementIterator, OtherIndexIterator, V, C, R, D> const& y ) const
-    {
-      return std::distance( this->order_it_, y.order_it_ );
-    }
-
-    template<class OtherElementIterator, class OtherIndexIterator, class V, class C, class R, class D >
-    bool
-    equal( permutation_iterator<OtherElementIterator, OtherIndexIterator, V, C, R, D> const& y ) const
-    {
-      return( y.order_it_ == this->order_it_ );
-    }
-
-    IndexIterator order_it_;
+    ElementIterator m_elt_iter;
 };
 
 

include/boost/iterator/reverse_iterator.hpp

@@ -1,11 +1,9 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 #ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP
 #define BOOST_REVERSE_ITERATOR_23022003THW_HPP
 

include/boost/iterator/transform_iterator.hpp

@@ -1,11 +1,9 @@
 // (C) Copyright David Abrahams 2002.
 // (C) Copyright Jeremy Siek    2002.
 // (C) Copyright Thomas Witt    2002.
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// 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)
 #ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
 #define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
 
@@ -124,7 +122,7 @@ namespace boost
     transform_iterator(
          transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t
        , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
-#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
+#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
        , typename enable_if_convertible<OtherUnaryFunction, UnaryFunction>::type* = 0
 #endif 
     )
@@ -158,9 +156,16 @@ namespace boost
   // function pointer in the iterator be 0, leading to a runtime
   // crash.
   template <class UnaryFunction, class Iterator>
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+  typename mpl::if_<
+#else 
   typename iterators::enable_if<
+#endif 
       is_class<UnaryFunction>   // We should probably find a cheaper test than is_class<>
     , transform_iterator<UnaryFunction, Iterator>
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    , int[3]
+#endif 
   >::type
   make_transform_iterator(Iterator it)
   {

include/boost/iterator/zip_iterator.hpp

@@ -19,6 +19,7 @@
 // Borland 5.5.1 (broken due to lack of support from Boost.Tuples)
 
 #ifndef BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
+# define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
 
 #include <stddef.h>
 #include <boost/iterator.hpp>
@@ -32,14 +33,10 @@
 
 #include <boost/tuple/tuple.hpp>
 
-#if BOOST_WORKAROUND(__GNUC__, == 2) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
-# include <boost/type_traits/remove_cv.hpp>
-#endif 
-
 #include <boost/type_traits/is_same.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/apply.hpp>
-#include <boost/mpl/apply_if.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/lambda.hpp>
 #include <boost/mpl/placeholders.hpp>
 #include <boost/mpl/aux_/lambda_support.hpp>
@@ -106,21 +103,13 @@ namespace boost {
       template<typename Iterator>
       struct apply
       { 
-#if BOOST_WORKAROUND(__GNUC__, == 2) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
         typedef typename
-        iterator_traits<
-            typename boost::remove_cv<Iterator>::type
-        >::reference
+          iterator_traits<Iterator>::reference
         type;
-#else 
-        typedef typename
-        iterator_traits<Iterator>::reference
-        type;
-#endif
       };
 
       template<typename Iterator>
-        typename apply<Iterator>::type operator()(Iterator& it)
+        typename apply<Iterator>::type operator()(Iterator const& it)
       { return *it; }
     };
            
@@ -152,7 +141,7 @@ namespace boost {
 
       template<typename Tuple, class UnaryMetaFun>
       struct tuple_meta_transform
-        : mpl::apply_if<
+        : mpl::eval_if<
               boost::is_same<Tuple, tuples::null_type>
             , mpl::identity<tuples::null_type>
             , tuple_meta_transform_impl<Tuple, UnaryMetaFun>
@@ -191,12 +180,12 @@ namespace boost {
         , typename StartType
       >
       struct tuple_meta_accumulate
-        : mpl::apply_if<
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+        : mpl::eval_if<
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
               mpl::or_<
 #endif 
                   boost::is_same<Tuple, tuples::null_type>
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
                 , boost::is_same<Tuple,int>
               >
 #endif 
@@ -349,7 +338,7 @@ namespace boost {
         typedef typename iterator_traits<Iterator>::reference type;
     };
 
-#ifdef BOOST_MPL_NO_FULL_LAMBDA_SUPPORT
+#ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
     // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
     // out well.  Instantiating the nested apply template also
     // requires instantiating iterator_traits on the
@@ -393,7 +382,7 @@ namespace boost {
       >::type type;
     };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
       template <>
       struct minimum_traversal_category_in_iterator_tuple<int>
       {
@@ -412,7 +401,7 @@ namespace boost {
       {
       };
     
-# ifdef BOOST_MPL_NO_FULL_LAMBDA_SUPPORT
+# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
   // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work
   // out well.  In this case I think it's an MPL bug
       template<>

include/boost/iterator_adaptors.hpp

@@ -1,13 +1,10 @@
-// Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-#ifndef BOOST_ITERATOR_ADAPTOR_13062003HK_HPP
-#define BOOST_ITERATOR_ADAPTOR_13062003HK_HPP
+// 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)
+#ifndef ITERATOR_ADAPTORS_DWA2004725_HPP
+# define ITERATOR_ADAPTORS_DWA2004725_HPP
 
 #define BOOST_ITERATOR_ADAPTORS_VERSION 0x0200
 #include <boost/iterator/iterator_adaptor.hpp>
 
-#endif // BOOST_ITERATOR_ADAPTOR_13062003HK_HPP
+#endif // ITERATOR_ADAPTORS_DWA2004725_HPP

include/boost/pending/detail/int_iterator.hpp

@@ -1,8 +1,7 @@
-//  (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
-//  sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
+//  (C) Copyright Jeremy Siek 1999.
+//  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)
 
 #ifndef BOOST_INT_ITERATOR_H
 #define BOOST_INT_ITERATOR_H

include/boost/pending/integer_range.hpp

@@ -1,8 +1,7 @@
-// (C) Copyright David Abrahams and Jeremy Siek 2000-2001. Permission to copy,
-// use, modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided "as is"
-// without express or implied warranty, and with no claim as to its suitability
-// for any purpose.
+// (C) Copyright David Abrahams and Jeremy Siek 2000-2001.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 // Revision History:
 // 04 Jan 2001  Factored counting_iterator stuff into
@@ -13,6 +12,7 @@
 
 #include <boost/config.hpp>
 #include <boost/iterator/counting_iterator.hpp>
+#include <algorithm>
 
 namespace boost {
 

include/boost/pending/iterator_adaptors.hpp

@@ -1,7 +1,6 @@
-// Copyright David Abrahams 2003. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
+// Copyright David Abrahams 2003.
+// 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)
 
 #include <boost/iterator_adaptors.hpp>

include/boost/pending/iterator_tests.hpp

@@ -1,8 +1,7 @@
-// Copyright David Abrahams and Jeremy Siek 2003. Permission to copy,
-// use, modify, sell and distribute this software is granted provided
-// this copyright notice appears in all copies. This software is
-// provided "as is" without express or implied warranty, and with no
-// claim as to its suitability for any purpose.
+// Copyright David Abrahams and Jeremy Siek 2003.
+// 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)
 #ifndef BOOST_ITERATOR_TESTS_HPP
 # define BOOST_ITERATOR_TESTS_HPP
 

include/boost/pointee.hpp

@@ -0,0 +1,74 @@
+#ifndef POINTEE_DWA200415_HPP
+# define POINTEE_DWA200415_HPP
+
+//
+// Copyright David Abrahams 2004. Use, modification and distribution is
+// subject to the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// typename pointee<P>::type provides the pointee type of P.
+//
+// For example, it is T for T* and X for shared_ptr<X>.
+//
+// http://www.boost.org/libs/iterator/doc/pointee.html
+//
+
+# include <boost/detail/is_incrementable.hpp>
+# include <boost/iterator/iterator_traits.hpp>
+# include <boost/type_traits/add_const.hpp>
+# include <boost/type_traits/remove_cv.hpp>
+# include <boost/mpl/if.hpp>
+# include <boost/mpl/eval_if.hpp>
+
+namespace boost { 
+
+namespace detail
+{
+  template <class P>
+  struct smart_ptr_pointee
+  {
+      typedef typename P::element_type type;
+  };
+
+  template <class Iterator>
+  struct iterator_pointee
+  {
+      typedef typename iterator_traits<Iterator>::value_type value_type;
+      
+      struct impl
+      {
+          template <class T>
+          static char test(T const&);
+          
+          static char (& test(value_type&) )[2];
+          
+          static Iterator& x;
+      };
+      
+      BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
+      
+      typedef typename mpl::if_c<
+#  if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+          ::boost::detail::iterator_pointee<Iterator>::is_constant
+#  else
+          is_constant
+#  endif 
+        , typename add_const<value_type>::type
+        , value_type
+      >::type type;
+  };
+}
+
+template <class P>
+struct pointee
+  : mpl::eval_if<
+        detail::is_incrementable<P>
+      , detail::iterator_pointee<P>
+      , detail::smart_ptr_pointee<P>
+    >
+{
+};
+  
+} // namespace boost
+
+#endif // POINTEE_DWA200415_HPP

test/Jamfile

@@ -1,50 +0,0 @@
-# Copyright David Abrahams 2003. Permission to copy, use,
-# modify, sell and distribute this software is granted provided this
-# copyright notice appears in all copies. This software is provided
-# "as is" without express or implied warranty, and with no claim as
-# to its suitability for any purpose.
-
-subproject libs/iterator/test ;
-
-import testing ;
-
-test-suite iterator
-  : 
-    # These first two tests will run last, and are expected to fail
-    # for many less-capable compilers.
-  
-    [ compile-fail interoperable_fail.cpp ]
-    # test uses expected success, so that we catch unrelated
-    # compilation problems.
-    [ run is_convertible_fail.cpp ]  
-
-    [ run zip_iterator_test.cpp ]
-      
-    # These tests should work for just about everything.
-    [ compile is_lvalue_iterator.cpp ]
-    [ compile is_readable_iterator.cpp ]
-      
-    [ run unit_tests.cpp ]
-    [ run concept_tests.cpp ]
-    [ run iterator_adaptor_cc.cpp ]
-    [ run iterator_adaptor_test.cpp ]
-    [ compile iterator_archetype_cc.cpp ]
-    [ run transform_iterator_test.cpp ]
-    [ run indirect_iterator_test.cpp ]
-    [ run filter_iterator_test.cpp ]
-    [ run reverse_iterator_test.cpp ]
-    [ run counting_iterator_test.cpp ]
-    [ run permutation_iterator_test.cpp : : : # <stlport-iostream>on 
-    ]
-      
-    [ run ../../utility/iterator_adaptor_examples.cpp ]
-    [ run ../../utility/counting_iterator_example.cpp ]
-    [ run ../../utility/filter_iterator_example.cpp ]
-    [ run ../../utility/fun_out_iter_example.cpp ]
-    [ run ../../utility/indirect_iterator_example.cpp ]
-    [ run ../../utility/projection_iterator_example.cpp ]
-    [ run ../../utility/reverse_iterator_example.cpp ]
-    [ run ../../utility/transform_iterator_example.cpp ]
-    [ run ../../utility/iterator_traits_test.cpp ]
-      
-;

test/Jamfile.v2

@@ -1,44 +0,0 @@
-# Copyright David Abrahams 2003. Permission to copy, use,
-# modify, sell and distribute this software is granted provided this
-# copyright notice appears in all copies. This software is provided
-# "as is" without express or implied warranty, and with no claim as
-# to its suitability for any purpose.
-
-import testing ;
-
-test-suite iterator
-  : 
-    # These first two tests will run last, and are expected to fail
-    # for many less-capable compilers.
-  
-    [ compile-fail interoperable_fail.cpp ]
-    # test uses expected success, so that we catch unrelated
-    # compilation problems.
-    [ run is_convertible_fail.cpp ]  
-
-    # These tests should work for just about everything.
-    [ run unit_tests.cpp ]
-    [ run concept_tests.cpp ]
-    [ run iterator_adaptor_cc.cpp ]
-    [ run iterator_adaptor_test.cpp ]
-    [ compile iterator_archetype_cc.cpp ]
-    [ run transform_iterator_test.cpp ]
-    [ run indirect_iterator_test.cpp ]
-    [ run filter_iterator_test.cpp ]
-    [ run reverse_iterator_test.cpp ]
-    [ run counting_iterator_test.cpp ]
-    [ run permutation_iterator_test.cpp : : : # <stlport-iostream>on 
-    ]
-    [ run zip_iterator_test.cpp ]
-      
-    [ run ../../utility/iterator_adaptor_examples.cpp ]
-    [ run ../../utility/counting_iterator_example.cpp ]
-    [ run ../../utility/filter_iterator_example.cpp ]
-    [ run ../../utility/fun_out_iter_example.cpp ]
-    [ run ../../utility/indirect_iterator_example.cpp ]
-    [ run ../../utility/projection_iterator_example.cpp ]
-    [ run ../../utility/reverse_iterator_example.cpp ]
-    [ run ../../utility/transform_iterator_example.cpp ]
-    [ run ../../utility/iterator_traits_test.cpp ]
-      
-;

test/concept_tests.cpp

@@ -1,83 +0,0 @@
-// (C) Copyright Jeremy Siek 2002. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-#include <boost/iterator/iterator_concepts.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/operators.hpp>
-
-struct new_random_access
-  : std::random_access_iterator_tag
-  , boost::random_access_traversal_tag
-{};
-
-struct new_iterator
-  : public boost::iterator< new_random_access, int >
-{
-  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()
-{
-  boost::iterator_traversal<new_iterator>::type tc;
-  boost::random_access_traversal_tag derived = tc;
-  (void)derived;
-  
-  boost::function_requires<
-    boost_concepts::WritableLvalueIteratorConcept<int*> >();
-  boost::function_requires<
-    boost_concepts::RandomAccessTraversalConcept<int*> >();
-
-  boost::function_requires<
-    boost_concepts::ReadableLvalueIteratorConcept<const int*> >();
-  boost::function_requires<
-    boost_concepts::RandomAccessTraversalConcept<const int*> >();
-
-  boost::function_requires<
-    boost_concepts::WritableLvalueIteratorConcept<new_iterator> >();
-  boost::function_requires<
-    boost_concepts::RandomAccessTraversalConcept<new_iterator> >();
-
-  boost::function_requires<
-    boost_concepts::WritableLvalueIteratorConcept<old_iterator> >();
-  boost::function_requires<
-    boost_concepts::RandomAccessTraversalConcept<old_iterator> >();
-  return 0;
-}