Bring branch up-to-date with trunk

[SVN r21992]

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
-#
-# <20> 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/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,98 +0,0 @@
-::
-
-  template <
-      class Iterator
-    , class Value = use_default
-    , unsigned Access  = use_default_access
-    , class Traversal  = use_default
-    , class Reference = use_default
-    , class Difference = use_default
-  >
-  class indirect_iterator
-    : public iterator_adaptor</* see discussion */>
-  {
-      friend class iterator_core_access;
-   public:
-      indirect_iterator();
-      indirect_iterator(Iterator x);
-      template <
-          class Iterator2, class Value2, unsigned Access2, class Traversal2
-        , class Reference2, class Difference2
-      >
-      indirect_iterator(
-          indirect_iterator<
-               Iterator2, Value2, Access2, Traversal2, 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();
-      }
-  };
-
-``indirect_iterator`` requirements
-..................................
-
-The ``value_type`` of the ``Iterator`` template parameter should
-itself be dereferenceable. The return type of the ``operator*`` for
-the ``value_type`` must be the same type as the ``Reference`` template
-parameter. The ``Value`` template parameter will be the ``value_type``
-for the ``indirect_iterator``, unless ``Value`` is const. If ``Value``
-is ``const X``, then ``value_type`` will be *non-* ``const X``.  The
-default for ``Value`` is
-
-::
-
-  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 ``Reference`` parameter will be the ``reference`` type of the
-``indirect_iterator``. The default is ``Value&``.
-
-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.
-
-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``.
-
-
-``indirect_iterator`` operations
-................................
-
-``indirect_iterator();``
-
-:Requires: ``Iterator`` must be Default Constructible.
-:Returns: An instance of ``indirect_iterator`` with
-    a default constructed base object.
-
-
-``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`` that is a copy of ``y``.
-

doc/issues.html

@@ -1,165 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.2.8: http://docutils.sourceforge.net/" />
-<title>Problem with is_writable and is_swappable in N1550</title>
-<link rel="stylesheet" href="default.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="problem-with-is-writable-and-is-swappable-in-n1550">
-<h1 class="title">Problem with <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> in <a class="reference" href="http://www.boost-consulting.com/writing/n1550.html">N1550</a></h1>
-<table class="field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Author:</th><td class="field-body">David Abrahams and Jeremy Siek</td>
-</tr>
-<tr class="field"><th class="field-name">Contact:</th><td class="field-body"><a class="reference" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a>, <a class="reference" href="mailto:jsiek&#64;osl.iu.edu">jsiek&#64;osl.iu.edu</a></td>
-</tr>
-<tr class="field"><th class="field-name">Organization:</th><td class="field-body"><a class="reference" href="http://www.boost-consulting.com">Boost Consulting</a>, Indiana University Bloomington</td>
-</tr>
-<tr class="field"><th class="field-name">date:</th><td class="field-body">$Date$</td>
-</tr>
-<tr class="field"><th class="field-name">Copyright:</th><td class="field-body">Copyright David Abrahams, Jeremy Siek 2003. Use, modification and
-distribution is subject to the Boost Software License,
-Version 1.0. (See accompanying file LICENSE_1_0.txt or copy
-at <a class="reference" href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</td>
-</tr>
-</tbody>
-</table>
-<div class="contents topic" id="table-of-contents">
-<p class="topic-title"><a name="table-of-contents">Table of Contents</a></p>
-<ul class="simple">
-<li><a class="reference" href="#introduction" id="id1" name="id1">Introduction</a></li>
-<li><a class="reference" href="#proposed-resolution" id="id2" name="id2">Proposed Resolution</a></li>
-<li><a class="reference" href="#rationale" id="id3" name="id3">Rationale</a></li>
-</ul>
-</div>
-<div class="section" id="introduction">
-<h1><a class="toc-backref" href="#id1" name="introduction">Introduction</a></h1>
-<p>The <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> traits classes in <a class="reference" href="http://www.boost-consulting.com/writing/n1550.html">N1550</a>
-provide a mechanism for determining at compile time if an iterator
-type is a model of the new Writable Iterator and Swappable Iterator
-concepts, analogous to <tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::iterator_category</span></tt>
-for the old iterator concepts. For backward compatibility,
-<tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> not only work with new
-iterators, but they also are intended to work for old
-iterators (iterators that meet the requirements for one of the
-iterator concepts in the current standard). In the case of old
-iterators, the writability and swapability is deduced based on the
-<tt class="literal"><span class="pre">iterator_category</span></tt> and also the <tt class="literal"><span class="pre">reference</span></tt> type. The
-specification for this deduction gives false positives for forward
-iterators that have non-assignable value types.</p>
-<p>To review, the part of the <tt class="literal"><span class="pre">is_writable</span></tt> trait definition which
-applies to old iterators is:</p>
-<pre class="literal-block">
-if (cat is convertible to output_iterator_tag)
-    return true;
-else if (cat is convertible to forward_iterator_tag
-         and iterator_traits&lt;Iterator&gt;::reference is a 
-             mutable reference)
-    return true;
-else
-    return false;
-</pre>
-<p>Suppose the <tt class="literal"><span class="pre">value_type</span></tt> of the iterator <tt class="literal"><span class="pre">It</span></tt> has a private
-assignment operator:</p>
-<pre class="literal-block">
-class B {
-public:
-  ...
-private:
-  B&amp; operator=(const B&amp;);
-};
-</pre>
-<p>and suppose the <tt class="literal"><span class="pre">reference</span></tt> type of the iterator is <tt class="literal"><span class="pre">B&amp;</span></tt>.  In
-that case, <tt class="literal"><span class="pre">is_writable&lt;It&gt;::value</span></tt> will be true when in fact
-attempting to write into <tt class="literal"><span class="pre">B</span></tt> will cause an error.</p>
-<p>The same problem applies to <tt class="literal"><span class="pre">is_swappable</span></tt>.</p>
-</div>
-<div class="section" id="proposed-resolution">
-<h1><a class="toc-backref" href="#id2" name="proposed-resolution">Proposed Resolution</a></h1>
-<ol class="arabic">
-<li><p class="first">Remove the <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> traits, and remove the
-requirements in the Writable Iterator and Swappable Iterator concepts
-that require their models to support these traits.</p>
-</li>
-<li><p class="first">Change the <tt class="literal"><span class="pre">is_readable</span></tt> specification to be:
-<tt class="literal"><span class="pre">is_readable&lt;X&gt;::type</span></tt> is <tt class="literal"><span class="pre">true_type</span></tt> if the
-result type of <tt class="literal"><span class="pre">X::operator*</span></tt> is convertible to
-<tt class="literal"><span class="pre">iterator_traits&lt;X&gt;::value_type</span></tt> and is <tt class="literal"><span class="pre">false_type</span></tt>
-otherwise. Also, <tt class="literal"><span class="pre">is_readable</span></tt> is required to satisfy
-the requirements for the UnaryTypeTrait concept
-(defined in the type traits proposal).</p>
-<p>Remove the requirement for support of the <tt class="literal"><span class="pre">is_readable</span></tt> trait from
-the Readable Iterator concept.</p>
-</li>
-<li><p class="first">Remove the <tt class="literal"><span class="pre">iterator_tag</span></tt> class.</p>
-</li>
-<li><p class="first">Change the specification of <tt class="literal"><span class="pre">traversal_category</span></tt> to:</p>
-<pre class="literal-block">
-traversal-category(Iterator) =
-    let cat = iterator_traits&lt;Iterator&gt;::iterator_category
-    if (cat is convertible to incrementable_iterator_tag)
-      return cat; // Iterator is a new iterator
-    else if (cat is convertible to random_access_iterator_tag)
-        return random_access_traversal_tag;
-    else if (cat is convertible to bidirectional_iterator_tag)
-        return bidirectional_traversal_tag;
-    else if (cat is convertible to forward_iterator_tag)
-        return forward_traversal_tag;
-    else if (cat is convertible to input_iterator_tag)
-        return single_pass_iterator_tag;
-    else if (cat is convertible to output_iterator_tag)
-        return incrementable_iterator_tag;
-    else
-        return null_category_tag;
-</pre>
-</li>
-</ol>
-</div>
-<div class="section" id="rationale">
-<h1><a class="toc-backref" href="#id3" name="rationale">Rationale</a></h1>
-<ol class="arabic simple">
-<li>There are two reasons for removing <tt class="literal"><span class="pre">is_writable</span></tt>
-and <tt class="literal"><span class="pre">is_swappable</span></tt>. The first is that we do not know of
-a way to fix the specification so that it gives the correct
-answer for all iterators. Second, there was only a weak
-motivation for having <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt>
-there in the first place.  The main motivation was simply
-uniformity: we have tags for the old iterator categories
-so we should have tags for the new iterator categories.
-While having tags and the capability to dispatch based
-on the traversal categories is often used, we see
-less of a need for dispatching based on writability
-and swappability, since typically algorithms
-that need these capabilities have no alternative if
-they are not provided.</li>
-<li>We discovered that the <tt class="literal"><span class="pre">is_readable</span></tt> trait can be implemented
-using only the iterator type itself and its <tt class="literal"><span class="pre">value_type</span></tt>.
-Therefore we remove the requirement for <tt class="literal"><span class="pre">is_readable</span></tt> from the
-Readable Iterator concept, and change the definition of
-<tt class="literal"><span class="pre">is_readable</span></tt> so that it works for any iterator type.</li>
-<li>The purpose of the <tt class="literal"><span class="pre">iterator_tag</span></tt> class was to
-bundle the traversal and access category tags
-into the <tt class="literal"><span class="pre">iterator_category</span></tt> typedef.
-With <tt class="literal"><span class="pre">is_writable</span></tt> and <tt class="literal"><span class="pre">is_swappable</span></tt> gone, and
-<tt class="literal"><span class="pre">is_readable</span></tt> no longer in need of special hints,
-there is no reason for iterators to provide
-information about the access capabilities of an iterator.
-Thus there is no need for the <tt class="literal"><span class="pre">iterator_tag</span></tt>. The
-traversal tag can be directly used for the
-<tt class="literal"><span class="pre">iterator_category</span></tt>. If a new iterator is intended to be backward
-compatible with old iterator concepts, a tag type
-that is convertible to both one of the new traversal tags 
-and also to an old iterator tag can be created and use
-for the <tt class="literal"><span class="pre">iterator_category</span></tt>.</li>
-<li>The changes to the specification of <tt class="literal"><span class="pre">traversal_category</span></tt> are a 
-direct result of the removal of <tt class="literal"><span class="pre">iterator_tag</span></tt>.</li>
-</ol>
-</div>
-</div>
-</body>
-</html>

doc/issues.rst

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

doc/iterator_adaptor.html

@@ -1,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=":">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>
-<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: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_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,167 +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
-  };
-
-__ : 
-
-``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,763 +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
-========================
-
-Proposed Changes for TR1
-========================
-
-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
-
-The algorithms in the standard library 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.
-
-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
-+++++++++++++++++++++++++++++++++
-
-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.
-Since the access concepts are not related via refinement, but instead
-cover orthogonal issues, we do not use tags for the access concepts,
-but instead use the equivalent of a bit field.
-
-We provide an access mechanism for mapping iterator types to the new
-traversal tags and access bit field. Our design reuses
-``iterator_traits<Iter>::iterator_category`` as the access
-mechanism. To that end, the access and traversal information is
-bundled into a single type using the following `iterator_tag` class.
-
-::
-
-  enum iterator_access { readable_iterator = 1, writable_iterator = 2, 
-      swappable_iterator = 4, lvalue_iterator = 8 };
-
-  template <unsigned int access_bits, class TraversalTag>
-  struct iterator_tag : /* appropriate old category or categories */ {
-    static const iterator_access access =
-      (iterator_access)access_bits & 
-        (readable_iterator | writable_iterator | swappable_iterator);
-    typedef TraversalTag traversal;
-  };
-
-The ``access_bits`` argument is declared to be ``unsigned int``
-instead of the enum ``iterator_access`` for convenience of use. For
-example, the expression ``(readable_iterator | writable_iterator)``
-produces an unsigned int, not an ``iterator_access``.  The purpose of
-the ``lvalue_iterator`` part of the ``iterator_access`` enum is to
-communicate to ``iterator_tag`` whether the reference type is an
-lvalue so that the appropriate old category can be chosen for the base
-class. The ``lvalue_iterator`` bit is not recorded in the
-``iterator_tag::access`` data member.
-
-The ``iterator_tag`` class template is derived from the appropriate
-iterator tag or tags from the old requirements based on the access
-bits and traversal tag passed as template parameters.  The algorithm
-for determining the old tag or tags picks the least-refined old
-concepts that include all of the requirements of the access and
-traversal concepts (that is, the closest fit), if any such category
-exists.  For example, the category tag for a Readable Single Pass
-Iterator will always be derived from ``input_iterator_tag``, while the
-category tag for a Single Pass Iterator that is both Readable and
-Writable will be derived from both ``input_iterator_tag`` and
-``output_iterator_tag``.
-
-We also provide several helper classes that make it convenient to
-obtain the access and traversal characteristics of an iterator. These
-helper classes work both for iterators whose ``iterator_category`` is
-``iterator_tag`` and also for iterators using the original iterator
-categories.
-
-::
-
-  template <class Iterator> struct is_readable  { typedef ... type; };
-  template <class Iterator> struct is_writable { typedef ... type; };
-  template <class Iterator> struct is_swappable { typedef ... type; };
-  template <class Iterator> struct traversal_category { typedef ... type; };
-
-
-We do not include a helper class ``is_lvalue_iterator`` because that
-can easily be deduced by checking whether
-``iterator_traits<Iterator>::reference`` is a real reference.
-
-
-The most 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``            |
-+-----------------------------------+------------------------+-------------------------+
-
-
-.. _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.  In addition, a model of *Writable Iterator* must include
-in its documentation the *set of value types* that it allows for
-output.
-
-+---------------------------------------------------------------------+
-|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``|                    |
-+--------------------------------+-------------------------------+--------------------+
-
-
-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``|                           |
-+--------------------------------+-----------------------------+---------------------------+
-
-
-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``          |               |
-+---------------------------------------+-----------------------------------+---------------+
-
-
-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``              |                     |
-|                                    |                                             |                     |
-+------------------------------------+---------------------------------------------+---------------------+
-
-
-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``                  |                         |                      |
-+-------------------------------------------+-------------------------------------------------+-------------------------+----------------------+
-
-
-
-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/style.tex

@@ -20,13 +20,13 @@
 % pagestyle
 % \usepackage{fancyhdr}
 \pagestyle{headings}
-\setlength{\paperwidth}{7.375in}
-\setlength{\paperheight}{9.25in}
+\setlength{\paperwidth}{8.5in}
+\setlength{\paperheight}{11in}
 
 \setlength{\oddsidemargin}{0.375in}
 \setlength{\evensidemargin}{0.375in}
-\setlength{\textwidth}{5in}
-\setlength{\textheight}{7.125in}
+\setlength{\textwidth}{6.125in}
+\setlength{\textheight}{8.875in}
 
 \setlength{\topmargin}{-0.375in}
 \setlength{\headheight}{0.25in}

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,93 +0,0 @@
-::
-
-  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 OtherIterator, class R2, class V2>
-    transform_iterator(
-          transform_iterator<UnaryFunction, OtherIterator, R2, V2> const& t
-        , typename enable_if_convertible<OtherIterator, Iterator>::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,55 +0,0 @@
-// (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.
-
-// Revision History:
-
-// 27 Feb 2001   Jeremy Siek
-//      Initial checkin.
-
-#ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
-#define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
-
-#include <iterator>
-
-namespace boost {
-
-  template <class UnaryFunction>
-  class function_output_iterator {
-    typedef function_output_iterator self;
-  public:
-    typedef std::output_iterator_tag iterator_category;
-    typedef void                value_type;
-    typedef void                difference_type;
-    typedef void                pointer;
-    typedef void                reference;
-
-    explicit function_output_iterator(const UnaryFunction& f = UnaryFunction())
-      : m_f(f) {}
-
-    struct output_proxy {
-      output_proxy(UnaryFunction& f) : m_f(f) { }
-      template <class T> output_proxy& operator=(const T& value) {
-        m_f(value); 
-        return *this; 
-      }
-      UnaryFunction& m_f;
-    };
-    output_proxy operator*() { return output_proxy(m_f); }
-    self& operator++() { return *this; } 
-    self& operator++(int) { return *this; }
-  private:
-    UnaryFunction m_f;
-  };
-
-  template <class UnaryFunction>
-  inline function_output_iterator<UnaryFunction>
-  make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
-    return function_output_iterator<UnaryFunction>(f);
-  }
-
-} // namespace boost
-
-#endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP

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,60 +0,0 @@
-//  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.
-
-//  See http://www.boost.org/libs/utility for documentation.
-
-//  Revision History
-//  12 Jan 01 added <cstddef> for std::ptrdiff_t (Jens Maurer)
-//  28 Jun 00 Workarounds to deal with known MSVC bugs (David Abrahams)
-//  26 Jun 00 Initial version (Jeremy Siek)
-
-#ifndef BOOST_ITERATOR_HPP
-#define BOOST_ITERATOR_HPP
-
-#include <iterator>
-#include <cstddef>           // std::ptrdiff_t
-#include <boost/config.hpp>
-
-namespace boost
-{
-# if defined(BOOST_NO_STD_ITERATOR) && !defined(BOOST_MSVC_STD_ITERATOR)
-  template <class Category, class T,
-    class Distance = std::ptrdiff_t,
-    class Pointer = T*, class Reference = T&>
-  struct iterator
-  {
-    typedef T         value_type;
-    typedef Distance  difference_type;
-    typedef Pointer   pointer;
-    typedef Reference reference;
-    typedef Category  iterator_category;
-  };
-# else
-
-  // declare iterator_base in namespace detail to work around MSVC bugs which
-  // prevent derivation from an identically-named class in a different namespace.
-  namespace detail {
-   template <class Category, class T, class Distance, class Pointer, class Reference>
-#  if !defined(BOOST_MSVC_STD_ITERATOR)
-   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
-#  else
-   struct iterator_base : std::iterator<Category, T, Distance>
-   {
-     typedef Reference reference;
-     typedef Pointer pointer;
-     typedef Distance difference_type;
-   };
-#  endif
-  }
-
-  template <class Category, class T, class Distance = std::ptrdiff_t,
-            class Pointer = T*, class Reference = T&>
-   struct iterator : detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
-# endif
-} // namespace boost
-
-#endif // BOOST_ITERATOR_HPP

include/boost/iterator/counting_iterator.hpp

@@ -1,210 +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.
-#ifndef COUNTING_ITERATOR_DWA200348_HPP
-# define COUNTING_ITERATOR_DWA200348_HPP
-
-# include <boost/iterator/iterator_adaptor.hpp>
-# include <boost/detail/numeric_traits.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/identity.hpp>
-# include <boost/mpl/apply_if.hpp>
-
-namespace boost {
-
-template <
-    class Incrementable
-  , class CategoryOrTraversal
-  , class Difference
->
-class counting_iterator;
-
-namespace detail
-{
-  // Try to detect numeric types at compile time in ways compatible
-  // with the limitations of the compiler and library.
-  template <class T>
-  struct is_numeric_impl
-  {
-      // For a while, this wasn't true, but we rely on it below. This is a regression assert.
-      BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
-      
-# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-      
-#  if defined(BOOST_HAS_LONG_LONG)
-      BOOST_STATIC_CONSTANT(
-          bool, value = (
-              std::numeric_limits<T>::is_specialized
-            | boost::is_same<T,long long>::value
-            | boost::is_same<T,unsigned long long>::value
-              ));
-#  else
-      BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
-#  endif
-      
-# else
-      
-#  if !defined(__BORLANDC__)
-      BOOST_STATIC_CONSTANT(
-          bool, value = (
-              boost::is_convertible<int,T>::value
-           && boost::is_convertible<T,int>::value
-      ));
-#  else
-    BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
-#  endif
-      
-# endif
-  };
-
-  template <class T>
-  struct is_numeric
-    : mpl::bool_<(::boost::detail::is_numeric_impl<T>::value)>
-  {};
-  
-  template <class T>
-  struct numeric_difference
-  {
-      typedef typename boost::detail::numeric_traits<T>::difference_type type;
-  };
-
-  BOOST_STATIC_ASSERT(is_numeric<int>::value);
-  
-  template <class Incrementable, class CategoryOrTraversal, class Difference>
-  struct counting_iterator_base
-  {
-      typedef typename detail::ia_dflt_help<
-          CategoryOrTraversal
-        , mpl::apply_if<
-              is_numeric<Incrementable>
-            , mpl::identity<random_access_traversal_tag>
-            , iterator_traversal<Incrementable>
-          >
-      >::type traversal;
-      
-      typedef typename detail::ia_dflt_help<
-          Difference
-        , mpl::apply_if<
-              is_numeric<Incrementable>
-            , numeric_difference<Incrementable>
-            , iterator_difference<Incrementable>
-          >
-      >::type difference;
-      
-      typedef iterator_adaptor<
-          counting_iterator<Incrementable, CategoryOrTraversal, Difference> // self
-        , Incrementable                                           // Base
-        , Incrementable                                           // Value
-# ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-          const  // MSVC won't strip this.  Instead we enable Thomas'
-                 // criterion (see boost/iterator/detail/facade_iterator_category.hpp)
-# endif 
-        , traversal
-        , Incrementable const&                                    // reference
-        , difference
-      > type;
-  };
-
-  // Template class distance_policy_select -- choose a policy for computing the
-  // distance between counting_iterators at compile-time based on whether or not
-  // the iterator wraps an integer or an iterator, using "poor man's partial
-  // specialization".
-
-  template <bool is_integer> struct distance_policy_select;
-
-  // A policy for wrapped iterators
-  template <class Difference, class Incrementable1, class Incrementable2>
-  struct iterator_distance
-  {
-      static Difference distance(Incrementable1 x, Incrementable2 y)
-      {
-          return boost::detail::distance(x, y);
-      }
-  };
-
-  // A policy for wrapped numbers
-  template <class Difference, class Incrementable1, class Incrementable2>
-  struct number_distance
-  {
-      static Difference distance(Incrementable1 x, Incrementable2 y)
-      {
-          return numeric_distance(x, y);
-      }
-  };
-}
-
-template <
-    class Incrementable
-  , class CategoryOrTraversal = use_default
-  , class Difference = use_default
->
-class counting_iterator
-  : public detail::counting_iterator_base<
-        Incrementable, CategoryOrTraversal, Difference
-    >::type
-{
-    typedef typename detail::counting_iterator_base<
-        Incrementable, CategoryOrTraversal, Difference
-    >::type super_t;
-    
-    friend class iterator_core_access;
-
- public:
-    typedef typename super_t::difference_type difference_type;
-
-    counting_iterator() { }
-    
-    counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {}
-
-    counting_iterator(Incrementable x)
-      : super_t(x)
-    {
-    }
-
-# if 0
-    template<class OtherIncrementable>
-    counting_iterator(
-        counting_iterator<OtherIncrementable> const& t
-      , typename enable_if_convertible<OtherIncrementable, Incrementable>::type* = 0
-    )
-      : super_t(t.base())
-    {}
-# endif 
-
- private:
-    
-    typename super_t::reference dereference() const
-    {
-        return this->base_reference();
-    }
-
-    template <class OtherIncrementable>
-    difference_type
-    distance_to(counting_iterator<OtherIncrementable> const& y) const
-    {
-      typedef typename mpl::if_<
-          detail::is_numeric<Incrementable>
-        , detail::number_distance<difference_type, Incrementable, OtherIncrementable>
-        , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>
-      >::type d;
-
-      return d::distance(this->base(), y.base());
-    }
-};
-
-// Manufacture a counting iterator for an arbitrary incrementable type
-template <class Incrementable>
-inline counting_iterator<Incrementable>
-make_counting_iterator(Incrementable x)
-{
-  typedef counting_iterator<Incrementable> result_t;
-  return result_t(x);
-}
-
-
-} // namespace boost::iterator
-
-#endif // COUNTING_ITERATOR_DWA200348_HPP

include/boost/iterator/detail/any_conversion_eater.hpp

@@ -1,19 +0,0 @@
-// Copyright David Abrahams 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)
-#ifndef ANY_CONVERSION_EATER_DWA20031117_HPP
-# define ANY_CONVERSION_EATER_DWA20031117_HPP
-
-namespace boost { namespace detail {
-
-// This type can be used in traits to "eat" up the one user-defined
-// implicit conversion allowed.
-struct any_conversion_eater
-{
-    template <class T>
-    any_conversion_eater(T const&);
-};
-
-}} // namespace boost::detail
-
-#endif // ANY_CONVERSION_EATER_DWA20031117_HPP

include/boost/iterator/detail/categories.hpp

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

include/boost/iterator/detail/config_def.hpp

@@ -1,163 +0,0 @@
-// (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.
-
-// no include guard multiple inclusion intended
-
-//
-// This is a temporary workaround until the bulk of this is
-// available in boost config.
-// 23/02/03 thw
-//
-
-#include <boost/config.hpp> // for prior
-#include <boost/detail/workaround.hpp>
-
-#ifdef BOOST_ITERATOR_CONFIG_DEF
-# error you have nested config_def #inclusion.
-#else 
-# define BOOST_ITERATOR_CONFIG_DEF
-#endif 
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)           \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))
-
-// Recall that in general, compilers without partial specialization
-// can't strip constness.  Consider counting_iterator, which normally
-// passes a const Value to iterator_facade.  As a result, any code
-// which makes a std::vector of the iterator's value_type will fail
-// when its allocator declares functions overloaded on reference and
-// const_reference (the same type).
-//
-// Furthermore, Borland 5.5.1 drops constness in enough ways that we
-// 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.
-
-# define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
-
-#endif
-
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                       \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))                   \
-    || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER))
-# define BOOST_NO_LVALUE_RETURN_DETECTION
-
-# if 0 // test code
-  struct v  {};
-
-  typedef  char (&no)[3];
-
-  template <class T>
-  no foo(T const&, ...);
-
-  template <class T>
-  char foo(T&, int);
-
-
-  struct value_iterator
-  {
-      v operator*() const;
-  };
-
-  template <class T>
-  struct lvalue_deref_helper
-  {
-      static T& x;
-      enum { value = (sizeof(foo(*x,0)) == 1) };
-  };
-
-  int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1];
-  int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ];
-# endif 
-
-#endif
-
-#if BOOST_WORKAROUND(BOOST_MSVC,  <= 1300)                      \
- || BOOST_WORKAROUND(__GNUC__, <= 2 && __GNUC_MINOR__ <= 95)    \
- || BOOST_WORKAROUND(__MWERKS__, <= 0x3000)                     \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-#  define BOOST_NO_SFINAE // "Substitution Failure Is Not An Error not implemented"
-
-#  if 0  // test code
-    template <bool x>
-    struct bar
-    {
-        typedef int type;
-    };
-
-    template <>
-    struct bar<false>
-    {
-    };
-
-
-    template <class T>
-    struct foo : bar<(sizeof(T) == 1)>
-    {
-    };
-
-    template <class T>
-    char* f(int, typename foo<T>::type = 0) { return 0; }
-
-    template <class T>
-    int f(...) { return 0; }
-
-    char* x = f<char>(0);
-    int y = f<char[2]>(0);
-
-    int main()
-    {
-        return 0;
-    }
-#  endif
-
-#endif
-
-#if BOOST_WORKAROUND(__MWERKS__, <=0x2407)
-#  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))
-#  define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
-
-#  if 0 // test code
-    template <class T>
-    struct foo
-    {
-        foo(T);
-
-        template <class U>
-        foo(foo<U> const& other) : p(other.p) { }
-
-        T p;
-    };
-
-    bool x = boost::is_convertible<foo<int const*>, foo<int*> >::value;
-#  endif
-
-#endif
-
-#if BOOST_WORKAROUND(__GNUC__, == 2 && __GNUC_MINOR__ == 95)    \
-  || BOOST_WORKAROUND(__MWERKS__, <= 0x2407)                    \
-  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-# 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)
-# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#endif 
-
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-#  define BOOST_ARG_DEPENDENT_TYPENAME typename
-# else
-#  define BOOST_ARG_DEPENDENT_TYPENAME
-# endif
-
-// no include guard multiple inclusion intended

include/boost/iterator/detail/config_undef.hpp

@@ -1,27 +0,0 @@
-// (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.
-
-// no include guard multiple inclusion intended
-
-//
-// This is a temporary workaround until the bulk of this is
-// available in boost config.
-// 23/02/03 thw
-//
-
-#undef BOOST_NO_SFINAE
-#undef BOOST_NO_IS_CONVERTIBLE
-#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
-#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#undef BOOST_ARG_DEPENDENT_TYPENAME
-#undef BOOST_NO_LVALUE_RETURN_DETECTION
-
-#ifdef BOOST_ITERATOR_CONFIG_DEF
-# undef BOOST_ITERATOR_CONFIG_DEF
-#else
-# error missing or nested #include config_def
-#endif 

include/boost/iterator/detail/enable_if.hpp

@@ -1,88 +0,0 @@
-// (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.
-#ifndef BOOST_ENABLE_IF_23022003THW_HPP
-#define BOOST_ENABLE_IF_23022003THW_HPP
-
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/identity.hpp>
-
-#include <boost/iterator/detail/config_def.hpp>
-
-//
-// Boost iterators uses its own enable_if cause we need
-// special semantics for deficient compilers.
-// 23/02/03 thw
-//
-
-namespace boost
-{
-
-  namespace iterators
-  {
-    //
-    // Base machinery for all kinds of enable if
-    //
-    template<bool>
-    struct enabled
-    {
-      template<typename T>
-      struct base
-      {
-        typedef T type;
-      };
-    };
-    
-    //
-    // For compilers that don't support "Substitution Failure Is Not An Error"
-    // enable_if falls back to always enabled. See comments
-    // on operator implementation for consequences.
-    //
-    template<>
-    struct enabled<false>
-    {
-      template<typename T>
-      struct base
-      {
-#ifdef BOOST_NO_SFINAE
-
-        typedef T type;
-
-        // This way to do it would give a nice error message containing
-        // invalid overload, but has the big disadvantage that
-        // there is no reference to user code in the error message.
-        //
-        // struct invalid_overload;
-        // typedef invalid_overload type;
-        //
-#endif
-      };
-    };
-
-
-    template <class Cond,
-              class Return>
-    struct enable_if
-# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
-      : enabled<(Cond::value)>::template base<Return>
-# else
-      : mpl::identity<Return>
-# endif 
-    {
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
-        typedef Return type;
-# endif 
-    };
-
-  } // namespace iterators
-
-} // namespace boost
-
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_ENABLE_IF_23022003THW_HPP

include/boost/iterator/detail/facade_iterator_category.hpp

@@ -1,212 +0,0 @@
-// Copyright David Abrahams 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)
-#ifndef FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
-# define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP
-
-# include <boost/iterator/iterator_categories.hpp>
-
-# include <boost/static_assert.hpp>
-
-# 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/identity.hpp>
-
-# include <boost/type_traits/is_same.hpp>
-# include <boost/type_traits/is_const.hpp>
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/is_convertible.hpp>
-
-# include <boost/type_traits/is_same.hpp>
-
-# 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>
-# endif
-
-//
-// iterator_category deduction for iterator_facade
-//
-
-// forward declaration
-namespace boost { struct use_default; }
-
-namespace boost { namespace detail  {
-
-struct input_output_iterator_tag
-  : std::input_iterator_tag
-{
-    // Using inheritance for only input_iterator_tag helps to avoid
-    // ambiguities when a stdlib implementation dispatches on a
-    // function which is overloaded on both input_iterator_tag and
-    // output_iterator_tag, as STLPort does, in its __valid_range
-    // function.  I claim it's better to avoid the ambiguity in these
-    // cases.
-    operator std::output_iterator_tag() const
-    {
-        return std::output_iterator_tag();
-    }
-};
-
-//
-// True iff the user has explicitly disabled writability of this
-// iterator.  Pass the iterator_facade's Value parameter and its
-// nested ::reference type.
-//
-template <class ValueParam, class Reference>
-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>
-      , is_const<ValueParam>
-    >
-# else 
-  : is_const<ValueParam>
-# endif 
-{};
-
-
-//
-// Convert an iterator_facade's traversal category, Value parameter,
-// and ::reference type to an appropriate old-style category.
-//
-// If writability has been disabled per the above metafunction, the
-// result will not be convertible to output_iterator_tag.
-//
-// Otherwise, if Traversal == single_pass_traversal_tag, the following
-// conditions will result in a tag that is convertible both to
-// input_iterator_tag and output_iterator_tag:
-//
-//    1. Reference is a reference to non-const
-//    2. Reference is not a reference and is convertible to Value
-//
-template <class Traversal, class ValueParam, class Reference>
-struct iterator_facade_default_category
-  : mpl::apply_if<
-        mpl::and_<
-            is_reference<Reference>
-          , is_convertible<Traversal,forward_traversal_tag>
-        >
-      , mpl::apply_if<
-            is_convertible<Traversal,random_access_traversal_tag>
-          , mpl::identity<std::random_access_iterator_tag>
-          , mpl::if_<
-                is_convertible<Traversal,bidirectional_traversal_tag>
-              , std::bidirectional_iterator_tag
-              , std::forward_iterator_tag
-            >
-        >
-      , typename mpl::apply_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>
-        >
-    >
-{
-};
-
-// True iff T is convertible to an old-style iterator category.
-template <class T>
-struct is_iterator_category
-  : mpl::or_<
-        is_convertible<T,std::input_iterator_tag>
-      , is_convertible<T,std::output_iterator_tag>
-    >
-{
-};
-
-template <class T>
-struct is_iterator_traversal
-  : is_convertible<T,incrementable_traversal_tag>
-{};
-
-//
-// A composite iterator_category tag convertible to Category (a pure
-// old-style category) and Traversal (a pure traversal tag).
-// Traversal must be a strict increase of the traversal power given by
-// Category.
-//
-template <class Category, class Traversal>
-struct iterator_category_with_traversal
-  : Category, Traversal
-{
-# if 0
-    // Because of limitations on multiple user-defined conversions,
-    // this should be a good test of whether convertibility is enough
-    // in the spec, or whether we need to specify inheritance.
-    operator Category() const { return Category(); }
-    operator Traversal() const { return Traversal(); }
-# endif
-    
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    // Make sure this isn't used to build any categories where
-    // convertibility to Traversal is redundant.  Should just use the
-    // Category element in that case.
-    BOOST_STATIC_ASSERT(
-        !(is_convertible<
-              typename iterator_category_to_traversal<Category>::type
-            , Traversal
-          >::value));
-
-    BOOST_STATIC_ASSERT(is_iterator_category<Category>::value);
-    BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
-    BOOST_STATIC_ASSERT(!is_iterator_traversal<Category>::value);
-    BOOST_STATIC_ASSERT(is_iterator_traversal<Traversal>::value);
-# endif 
-};
-
-// Computes an iterator_category tag whose traversal is Traversal and
-// which is appropriate for an iterator
-template <class Traversal, class ValueParam, class Reference>
-struct facade_iterator_category_impl
-{
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
-# endif 
-    
-    typedef typename iterator_facade_default_category<
-        Traversal,ValueParam,Reference
-    >::type category;
-    
-    typedef typename mpl::if_<
-        is_same<
-            Traversal
-          , typename iterator_category_to_traversal<category>::type
-        >
-      , category
-      , iterator_category_with_traversal<category,Traversal>
-    >::type type;
-};
-
-//
-// Compute an iterator_category for iterator_facade
-//
-template <class CategoryOrTraversal, class ValueParam, class Reference>
-struct facade_iterator_category
-  : mpl::apply_if<
-        is_iterator_category<CategoryOrTraversal>
-      , mpl::identity<CategoryOrTraversal> // old-style categories are fine as-is
-      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
-    >
-{
-};
-
-}} // namespace boost::detail
-
-# include <boost/iterator/detail/config_undef.hpp>
-
-#endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP

include/boost/iterator/detail/minimum_category.hpp

@@ -1,104 +0,0 @@
-// Copyright David Abrahams 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)
-#ifndef MINIMUM_CATEGORY_DWA20031119_HPP
-# define MINIMUM_CATEGORY_DWA20031119_HPP
-
-# include <boost/type_traits/is_convertible.hpp>
-# include <boost/type_traits/is_same.hpp>
-
-# include <boost/mpl/aux_/lambda_support.hpp>
-
-namespace boost { namespace detail { 
-//
-// Returns the minimum category type or error_type
-// if T1 and T2 are unrelated.
-//
-// For compilers not supporting is_convertible this only
-// works with the new boost return and traversal category
-// types. The exact boost _types_ are required. No derived types
-// will work. 
-//
-//
-template <bool GreaterEqual, bool LessEqual>
-struct minimum_category_impl;
-
-template <class T1, class T2>
-struct error_not_related_by_convertibility;
-  
-template <>
-struct minimum_category_impl<true,false>
-{
-    template <class T1, class T2> struct apply
-    {
-        typedef T2 type;
-    };
-};
-
-template <>
-struct minimum_category_impl<false,true>
-{
-    template <class T1, class T2> struct apply
-    {
-        typedef T1 type;
-    };
-};
-
-template <>
-struct minimum_category_impl<true,true>
-{
-    template <class T1, class T2> struct apply
-    {
-        BOOST_STATIC_ASSERT((is_same<T1,T2>::value));
-        typedef T1 type;
-    };
-};
-
-template <>
-struct minimum_category_impl<false,false>
-{
-    template <class T1, class T2> struct apply
-# 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< 
-        ::boost::is_convertible<T1,T2>::value
-      , ::boost::is_convertible<T2,T1>::value
-    > outer;
-      
-    typedef typename outer::template apply<T1,T2> inner;
-    typedef typename inner::type type;
-      
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(2,minimum_category,(T1,T2))
-};
-    
-template <>
-struct minimum_category<mpl::_1,mpl::_2>
-{
-    template <class T1, class T2>
-    struct apply : minimum_category<T1,T2>
-    {};
-};
-    
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
-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,137 +0,0 @@
-// (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.
-#ifndef BOOST_FILTER_ITERATOR_23022003THW_HPP
-#define BOOST_FILTER_ITERATOR_23022003THW_HPP
-
-#include <boost/iterator.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-
-#include <boost/type_traits/is_class.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost
-{
-  template <class Predicate, class Iterator>
-  class filter_iterator;
-
-  namespace detail
-  {
-    template <class Predicate, class Iterator>
-    struct filter_iterator_base
-    {
-        typedef iterator_adaptor<
-            filter_iterator<Predicate, Iterator>
-          , Iterator
-          , use_default
-          , typename mpl::if_<
-                is_convertible<
-                    typename iterator_traversal<Iterator>::type
-                  , bidirectional_traversal_tag
-                >
-              , forward_traversal_tag
-              , use_default
-            >::type
-        > type;
-    };
-  }
-  
-  template <class Predicate, class Iterator>
-  class filter_iterator
-    : public detail::filter_iterator_base<Predicate, Iterator>::type
-  {
-      typedef typename detail::filter_iterator_base<
-          Predicate, Iterator
-      >::type super_t;
-
-      friend class iterator_core_access;
-
-   public:
-      filter_iterator() { }
-
-      filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
-          : super_t(x), m_predicate(f), m_end(end)
-      {
-          satisfy_predicate();
-      }
-
-      filter_iterator(Iterator x, Iterator end = Iterator())
-        : super_t(x), m_predicate(), m_end(end)
-      {
-        // Pro8 is a little too aggressive about instantiating the
-        // body of this function.
-#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-          // Don't allow use of this constructor if Predicate is a
-          // function pointer type, since it will be 0.
-          BOOST_STATIC_ASSERT(is_class<Predicate>::value);
-#endif 
-          satisfy_predicate();
-      }
-
-      template<class OtherIterator>
-      filter_iterator(
-          filter_iterator<Predicate, OtherIterator> const& t
-          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
-          )
-          : super_t(t.base()), m_predicate(t.predicate()), m_end(t.end()) {}
-
-      Predicate predicate() const { return m_predicate; }
-
-      Iterator end() const { return m_end; }
-
-   private:
-      void increment()
-      {
-          ++(this->base_reference());
-          satisfy_predicate();
-      }
-
-      void decrement()
-      {
-        while(!this->m_predicate(*--(this->base_reference()))){};
-      }
-
-      void satisfy_predicate()
-      {
-          while (this->base() != this->m_end && !this->m_predicate(*this->base()))
-              ++(this->base_reference());
-      }
-
-      // Probably should be the initial base class so it can be
-      // optimized away via EBO if it is an empty class.
-      Predicate m_predicate;
-      Iterator m_end;
-  };
-
-  template <class Predicate, class Iterator>
-  filter_iterator<Predicate,Iterator>
-  make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
-  {
-      return filter_iterator<Predicate,Iterator>(f,x,end);
-  }
-
-  template <class Predicate, class Iterator>
-  filter_iterator<Predicate,Iterator>
-  make_filter_iterator(
-      typename iterators::enable_if<
-          is_class<Predicate>
-        , Iterator
-      >::type x
-    , Iterator end = Iterator()
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
-    , Predicate* = 0
-#endif 
-  )
-  {
-      return filter_iterator<Predicate,Iterator>(x,end);
-  }
-
-} // namespace boost
-
-#endif // BOOST_FILTER_ITERATOR_23022003THW_HPP

include/boost/iterator/indirect_iterator.hpp

@@ -1,251 +0,0 @@
-// (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.
-#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/type_traits/remove_cv.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/not.hpp>
-#include <boost/mpl/aux_/has_xxx.hpp>
-
-#ifdef BOOST_MPL_NO_AUX_HAS_XXX
-# include <boost/shared_ptr.hpp>
-# include <boost/scoped_ptr.hpp>
-# include <boost/mpl/bool.hpp>
-# include <memory>
-#endif 
-
-#include <boost/iterator/detail/config_def.hpp> // must be last #include
-
-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
-    {
-        typedef typename iterator_traits<Iter>::value_type dereferenceable;
-        
-        typedef iterator_adaptor<
-            indirect_iterator<Iter, Value, Category, Reference, Difference>
-          , Iter
-          , typename ia_dflt_help<
-                Value, default_indirect_value<dereferenceable>
-            >::type
-          , Category
-          , Reference
-          , Difference
-        > type;
-    };
-
-    template <>
-    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
-    , class Value = use_default
-    , class Category = use_default
-    , class Reference = use_default
-    , class Difference = use_default
-  >
-  class indirect_iterator
-    : public detail::indirect_base<
-        Iterator, Value, Category, Reference, Difference
-      >::type
-  {
-      typedef typename detail::indirect_base<
-          Iterator, Value, Category, Reference, Difference
-      >::type super_t;
-
-      friend class iterator_core_access;
-
-   public:
-      indirect_iterator() {}
-
-      indirect_iterator(Iterator iter)
-        : super_t(iter) {}
-
-      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
-      )
-        : super_t(y.base())
-      {}
-
-  private:    
-      typename super_t::reference dereference() const
-      {
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-          return const_cast<super_t::reference>(**this->base());
-# else
-          return **this->base();
-# endif 
-      }
-  };
-
-  template <class Iter>
-  inline
-  indirect_iterator<Iter> make_indirect_iterator(Iter x)
-  {
-    return indirect_iterator<Iter>(x);
-  }
-
-  template <class Traits, class Iter>
-  inline
-  indirect_iterator<Iter,Traits> make_indirect_iterator(Iter x, Traits* = 0)
-  {
-    return indirect_iterator<Iter, Traits>(x);
-  }
-
-} // namespace boost
-
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_INDIRECT_ITERATOR_23022003THW_HPP

include/boost/iterator/interoperable.hpp

@@ -1,52 +0,0 @@
-// (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.
-#ifndef BOOST_INTEROPERABLE_23022003THW_HPP
-# define BOOST_INTEROPERABLE_23022003THW_HPP
-
-# include <boost/mpl/bool.hpp>
-# include <boost/mpl/or.hpp>
-
-# include <boost/type_traits/is_convertible.hpp>
-
-# include <boost/iterator/detail/config_def.hpp> // must appear last
-
-namespace boost
-{
-
-  //
-  // Meta function that determines whether two
-  // iterator types are considered interoperable.
-  //
-  // Two iterator types A,B are considered interoperable if either
-  // A is convertible to B or vice versa.
-  // This interoperability definition is in sync with the
-  // standards requirements on constant/mutable container
-  // iterators (23.1 [lib.container.requirements]).
-  //
-  // For compilers that don't support is_convertible 
-  // is_interoperable gives false positives. See comments
-  // on operator implementation for consequences.
-  //
-  template <typename A, typename B>
-  struct is_interoperable
-# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-    : mpl::true_
-# else
-    : mpl::or_<
-          is_convertible< A, B >
-        , is_convertible< B, A > >
-# endif
-  { 
-  };
-
-} // namespace boost
-
-# include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_INTEROPERABLE_23022003THW_HPP

include/boost/iterator/is_lvalue_iterator.hpp

@@ -1,150 +0,0 @@
-// Copyright David Abrahams 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)
-#ifndef IS_LVALUE_ITERATOR_DWA2003112_HPP
-# define IS_LVALUE_ITERATOR_DWA2003112_HPP
-
-#include <boost/iterator.hpp>
-
-#include <boost/detail/workaround.hpp>
-#include <boost/detail/iterator.hpp>
-
-#include <boost/iterator/detail/any_conversion_eater.hpp>
-
-// should be the last #includes
-#include <boost/type_traits/detail/bool_trait_def.hpp>
-#include <boost/iterator/detail/config_def.hpp>
-
-#ifndef BOOST_NO_IS_CONVERTIBLE
-
-namespace boost {
- 
-namespace detail
-{
-#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-  // Calling lvalue_preserver( <expression>, 0 ) returns a reference
-  // to the expression's result if <expression> is an lvalue, or
-  // not_an_lvalue() otherwise.
-  struct not_an_lvalue {};
-  
-  template <class T>
-  T& lvalue_preserver(T&, int);
-  
-  template <class U>
-  not_an_lvalue lvalue_preserver(U const&, ...);
-  
-# define BOOST_LVALUE_PRESERVER(expr) lvalue_preserver(expr,0)
-  
-#else
-  
-# define BOOST_LVALUE_PRESERVER(expr) expr
-  
-#endif 
-
-  // Guts of is_lvalue_iterator.  Value is the iterator's value_type
-  // and the result is computed in the nested rebind template.
-  template <class Value>
-  struct is_lvalue_iterator_impl
-  {
-      // Eat implicit conversions so we don't report true for things
-      // convertible to Value const&
-      struct conversion_eater
-      {
-          conversion_eater(Value&);
-      };
-
-      static char tester(conversion_eater, int);
-      static char (& tester(any_conversion_eater, ...) )[2];
-    
-      template <class It>
-      struct rebind
-      {
-          static It& x;
-          
-          BOOST_STATIC_CONSTANT(
-              bool
-            , value = (
-                sizeof(
-                    is_lvalue_iterator_impl<Value>::tester(
-                        BOOST_LVALUE_PRESERVER(*x), 0
-                    )
-                ) == 1
-            )
-          );
-      };
-  };
-
-#undef BOOST_LVALUE_PRESERVER
-  
-  //
-  // void specializations to handle std input and output iterators
-  //
-  template <>
-  struct is_lvalue_iterator_impl<void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-  template <>
-  struct is_lvalue_iterator_impl<const void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-  template <>
-  struct is_lvalue_iterator_impl<volatile void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-  template <>
-  struct is_lvalue_iterator_impl<const volatile void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-#endif
-
-  //
-  // This level of dispatching is required for Borland.  We might save
-  // an instantiation by removing it for others.
-  //
-  template <class It>
-  struct is_readable_lvalue_iterator_impl
-    : is_lvalue_iterator_impl<
-          BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type const
-      >::template rebind<It>
-  {};
-
-  template <class It>
-  struct is_non_const_lvalue_iterator_impl
-    : is_lvalue_iterator_impl<
-          BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type
-      >::template rebind<It>
-  {};
-} // namespace detail
-
-// Define the trait with full mpl lambda capability and various broken
-// compiler workarounds
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_lvalue_iterator,T,::boost::detail::is_readable_lvalue_iterator_impl<T>::value)
-    
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_non_const_lvalue_iterator,T,::boost::detail::is_non_const_lvalue_iterator_impl<T>::value)
-    
-} // namespace boost
-
-#endif
-
-#include <boost/iterator/detail/config_undef.hpp>
-#include <boost/type_traits/detail/bool_trait_undef.hpp>
-
-#endif // IS_LVALUE_ITERATOR_DWA2003112_HPP

include/boost/iterator/is_readable_iterator.hpp

@@ -1,108 +0,0 @@
-// Copyright David Abrahams 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)
-#ifndef IS_READABLE_ITERATOR_DWA2003112_HPP
-# define IS_READABLE_ITERATOR_DWA2003112_HPP
-
-#include <boost/mpl/bool.hpp>
-#include <boost/detail/iterator.hpp>
-
-#include <boost/type_traits/detail/bool_trait_def.hpp>
-#include <boost/iterator/detail/any_conversion_eater.hpp>
-
-// should be the last #include
-#include <boost/iterator/detail/config_def.hpp>
-
-#ifndef BOOST_NO_IS_CONVERTIBLE
-
-namespace boost {
- 
-namespace detail
-{
-  // Guts of is_readable_iterator.  Value is the iterator's value_type
-  // and the result is computed in the nested rebind template.
-  template <class Value>
-  struct is_readable_iterator_impl
-  {
-      static char tester(Value&, int);
-      static char (& tester(any_conversion_eater, ...) )[2];
-    
-      template <class It>
-      struct rebind
-      {
-          static It& x;
-          
-          BOOST_STATIC_CONSTANT(
-              bool
-            , value = (
-                sizeof(
-                    is_readable_iterator_impl<Value>::tester(*x, 1)
-                ) == 1
-            )
-          );
-      };
-  };
-
-#undef BOOST_READABLE_PRESERVER
-  
-  //
-  // void specializations to handle std input and output iterators
-  //
-  template <>
-  struct is_readable_iterator_impl<void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-  template <>
-  struct is_readable_iterator_impl<const void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-  template <>
-  struct is_readable_iterator_impl<volatile void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-
-  template <>
-  struct is_readable_iterator_impl<const volatile void>
-  {
-      template <class It>
-      struct rebind : boost::mpl::false_
-      {};
-  };
-#endif
-
-  //
-  // This level of dispatching is required for Borland.  We might save
-  // an instantiation by removing it for others.
-  //
-  template <class It>
-  struct is_readable_iterator_impl2
-    : is_readable_iterator_impl<
-          BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type const
-      >::template rebind<It>
-  {};
-} // namespace detail
-
-// Define the trait with full mpl lambda capability and various broken
-// compiler workarounds
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
-    is_readable_iterator,T,::boost::detail::is_readable_iterator_impl2<T>::value)
-    
-} // namespace boost
-
-#endif
-
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // IS_READABLE_ITERATOR_DWA2003112_HPP

include/boost/iterator/iterator_adaptor.hpp

@@ -1,345 +0,0 @@
-// (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.
-#ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
-#define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
-
-#include <boost/static_assert.hpp>
-#include <boost/iterator.hpp>
-#include <boost/detail/iterator.hpp>
-
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/detail/enable_if.hpp>
-
-#include <boost/mpl/and.hpp>
-#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>
-
-#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-# include <boost/type_traits/remove_reference.hpp>
-#else 
-# include <boost/type_traits/add_reference.hpp>
-#endif 
-
-#include <boost/iterator/detail/config_def.hpp>
-
-#include <boost/iterator/iterator_traits.hpp>
-
-namespace boost
-{
-  // Used as a default template argument internally, merely to
-  // indicate "use the default", this can also be passed by users
-  // explicitly in order to specify that the default should be used.
-  struct use_default;
-  
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  // the incompleteness of use_default causes massive problems for
-  // is_convertible (naturally).  This workaround is fortunately not
-  // needed for vc6/vc7.
-  template<class To>
-  struct is_convertible<use_default,To>
-    : mpl::false_ {};
-# endif 
-  
-  namespace detail
-  {
-
-    // 
-    // Result type used in enable_if_convertible meta function.
-    // This can be an incomplete type, as only pointers to 
-    // enable_if_convertible< ... >::type are used.
-    // We could have used void for this, but conversion to
-    // void* is just to easy.
-    //
-    struct enable_type;
-  }
-
-
-  //
-  // enable_if for use in adapted iterators constructors.
-  //
-  // In order to provide interoperability between adapted constant and
-  // mutable iterators, adapted iterators will usually provide templated
-  // conversion constructors of the following form
-  //
-  // template <class BaseIterator>
-  // class adapted_iterator :
-  //   public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
-  // {
-  // public:
-  //   
-  //   ...
-  //
-  //   template <class OtherIterator>
-  //   adapted_iterator(
-  //       OtherIterator const& it
-  //     , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0);
-  //
-  //   ...
-  // };
-  //
-  // enable_if_convertible is used to remove those overloads from the overload
-  // set that cannot be instantiated. For all practical purposes only overloads
-  // for constant/mutable interaction will remain. This has the advantage that
-  // meta functions like boost::is_convertible do not return false positives,
-  // as they can only look at the signature of the conversion constructor
-  // and not at the actual instantiation.
-  //
-  // enable_if_interoperable can be safely used in user code. It falls back to
-  // always enabled for compilers that don't support enable_if or is_convertible. 
-  // There is no need for compiler specific workarounds in user code. 
-  //
-  // The operators implementation relies on boost::is_convertible not returning
-  // false positives for user/library defined iterator types. See comments
-  // on operator implementation for consequences.
-  //
-#  if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
-  
-  template <class From, class To>
-  struct enable_if_convertible
-  {
-      typedef detail::enable_type type;
-  };
-  
-#  elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC > 1300
-  
-  // For some reason vc7.1 needs us to "cut off" instantiation
-  // of is_convertible in a few cases.
-  template<typename From, typename To>
-  struct enable_if_convertible
-    : iterators::enable_if<
-        mpl::or_<
-            is_same<From,To>
-          , is_convertible<From, To>
-        >
-      , detail::enable_type
-    >
-  {};
-  
-#  else 
-  
-  template<typename From, typename To>
-  struct enable_if_convertible
-    : iterators::enable_if<
-          is_convertible<From, To>
-        , detail::enable_type
-      >
-  {};
-      
-# endif
-  
-  //
-  // Default template argument handling for iterator_adaptor
-  //
-  namespace detail
-  {
-    // If T is use_default, return the result of invoking
-    // DefaultNullaryFn, otherwise return T.
-    template <class T, class DefaultNullaryFn>
-    struct ia_dflt_help
-      : mpl::apply_if<
-            is_same<T, use_default>
-          , DefaultNullaryFn
-          , mpl::identity<T>
-        >
-    {
-    };
-
-    // A metafunction which computes an iterator_adaptor's base class,
-    // a specialization of iterator_facade.
-    template <
-        class Derived
-      , class Base
-      , class Value
-      , class Traversal
-      , class Reference
-      , class Difference
-    >
-    struct iterator_adaptor_base
-    {
-        typedef iterator_facade<
-            Derived
-            
-# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
-          , typename detail::ia_dflt_help<
-                Value
-              , mpl::apply_if<
-                    is_same<Reference,use_default>
-                  , iterator_value<Base>
-                  , remove_reference<Reference>
-                >
-            >::type
-# else
-          , typename detail::ia_dflt_help<
-                Value, iterator_value<Base>
-            >::type
-# endif
-            
-          , typename detail::ia_dflt_help<
-                Traversal
-              , iterator_traversal<Base>
-            >::type
-
-          , typename detail::ia_dflt_help<
-                Reference
-              , mpl::apply_if<
-                    is_same<Value,use_default>
-                  , iterator_reference<Base>
-                  , add_reference<Value>
-                >
-            >::type
-
-          , typename detail::ia_dflt_help<
-                Difference, iterator_difference<Base>
-            >::type
-        >
-        type;
-    };
-    template <class T> int static_assert_convertible_to(T);
-  }
-  
-  //
-  // Iterator Adaptor
-  //
-  // The parameter ordering changed slightly with respect to former
-  // versions of iterator_adaptor The idea is that when the user needs
-  // to fiddle with the reference type it is highly likely that the
-  // iterator category has to be adjusted as well.  Any of the
-  // following four template arguments may be ommitted or explicitly
-  // replaced by use_default.
-  //
-  //   Value - if supplied, the value_type of the resulting iterator, unless
-  //      const. If const, a conforming compiler strips constness for the
-  //      value_type. If not supplied, iterator_traits<Base>::value_type is used
-  //
-  //   Category - the traversal category of the resulting iterator. If not
-  //      supplied, iterator_traversal<Base>::type is used.
-  //
-  //   Reference - the reference type of the resulting iterator, and in
-  //      particular, the result type of operator*(). If not supplied but
-  //      Value is supplied, Value& is used. Otherwise
-  //      iterator_traits<Base>::reference is used.
-  //
-  //   Difference - the difference_type of the resulting iterator. If not
-  //      supplied, iterator_traits<Base>::difference_type is used.
-  //
-  template <
-      class Derived
-    , class Base
-    , class Value        = use_default
-    , class Traversal    = use_default
-    , class Reference    = use_default
-    , class Difference   = use_default
-  >
-  class iterator_adaptor
-    : public detail::iterator_adaptor_base<
-        Derived, Base, Value, Traversal, Reference, Difference
-      >::type
-  {
-      friend class iterator_core_access;
-
-      typedef typename detail::iterator_adaptor_base<
-          Derived, Base, Value, Traversal, Reference, Difference
-      >::type super_t;
-
-   public:
-      iterator_adaptor() {}
-
-      explicit iterator_adaptor(Base iter)
-          : m_iterator(iter)
-      {
-      }
-
-      Base base() const
-        { return m_iterator; }
-
-   protected:
-      //
-      // lvalue access to the Base object for Derived
-      //
-      Base const& base_reference() const
-        { return m_iterator; }
-
-      Base& base_reference()
-        { return m_iterator; }
-
-   private:
-      //
-      // Core iterator interface for iterator_facade.  This is private
-      // to prevent temptation for Derived classes to use it, which
-      // will often result in an error.  Derived classes should use
-      // base_reference(), above, to get direct access to m_iterator.
-      // 
-      typename super_t::reference dereference() const
-        { return *m_iterator; }
-
-      template <
-      class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
-      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
-      {
-        // Maybe readd with same_distance
-        //           BOOST_STATIC_ASSERT(
-        //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
-        //               );
-          return m_iterator == x.base();
-      }
-
-      typedef typename iterator_category_to_traversal<
-          typename super_t::iterator_category
-      >::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));
-
-      void advance(typename super_t::difference_type n)
-      {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
-          m_iterator += n;
-      }
-  
-      void increment() { ++m_iterator; }
-
-      void decrement() 
-      {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)
-           --m_iterator;
-      }
-
-      template <
-          class OtherDerived, class OtherIterator, class V, class C, class R, class D
-      >   
-      typename super_t::difference_type distance_to(
-          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
-      {
-          BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
-          // Maybe readd with same_distance
-          //           BOOST_STATIC_ASSERT(
-          //               (detail::same_category_and_difference<Derived,OtherDerived>::value)
-          //               );
-          return y.base() - m_iterator;
-      }
-
-# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL
-      
-   private: // data members
-      Base m_iterator;
-  };
-
-} // namespace boost
-
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_ITERATOR_ADAPTOR_23022003THW_HPP

include/boost/iterator/iterator_archetypes.hpp

@@ -1,458 +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.
-
-#ifndef BOOST_ITERATOR_ARCHETYPES_HPP
-#define BOOST_ITERATOR_ARCHETYPES_HPP
-
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/operators.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/iterator.hpp>
-
-#include <boost/iterator/detail/facade_iterator_category.hpp>
-
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_cv.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/and.hpp>
-#include <boost/mpl/identity.hpp>
-
-#include <cstddef>
-
-namespace boost {
-
-template <class Value, class AccessCategory>
-struct access_archetype;
-
-template <class Derived, class Value, class AccessCategory, class TraversalCategory>
-struct traversal_archetype;
-
-namespace iterator_archetypes
-{
-  enum {
-      readable_iterator_bit = 1
-    , writable_iterator_bit = 2
-    , swappable_iterator_bit = 4
-    , lvalue_iterator_bit = 8
-  };
-
-  // Not quite tags, since dispatching wouldn't work.
-  typedef mpl::int_<readable_iterator_bit>::type readable_iterator_t;
-  typedef mpl::int_<writable_iterator_bit>::type writable_iterator_t;
-  
-  typedef mpl::int_<
-      (readable_iterator_bit|writable_iterator_bit)
-          >::type readable_writable_iterator_t;
-  
-  typedef mpl::int_<
-      (readable_iterator_bit|lvalue_iterator_bit)
-          >::type readable_lvalue_iterator_t;
-  
-  typedef mpl::int_<
-      (lvalue_iterator_bit|writable_iterator_bit)
-          >::type writable_lvalue_iterator_t;
-  
-  typedef mpl::int_<swappable_iterator_bit>::type swappable_iterator_t;
-  typedef mpl::int_<lvalue_iterator_bit>::type lvalue_iterator_t;
-
-  template <class Derived, class Base>
-  struct has_access
-    : mpl::equal_to<
-          mpl::bitand_<Derived,Base>
-        , Base
-      >
-  {};
-}
-
-namespace detail
-{
-  template <class T>
-  struct assign_proxy
-  {
-      assign_proxy& operator=(T);
-  };
-
-  template <class T>
-  struct read_proxy
-  {
-      operator T();
-  };
-
-  template <class T>
-  struct read_write_proxy
-    : assign_proxy<T>
-    , read_proxy<T>
-  {
-  };
-
-  template <class T>
-  struct arrow_proxy
-  {
-      T const* operator->() const;
-  };
-
-  struct no_operator_brackets {};
-
-  template <class ValueType>
-  struct readable_operator_brackets
-  {
-      read_proxy<ValueType> operator[](std::ptrdiff_t n) const;
-  };
-
-  template <class ValueType>
-  struct writable_operator_brackets
-  {
-      read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const;
-  };
-
-  template <class Value, class AccessCategory, class TraversalCategory>
-  struct operator_brackets
-    : mpl::aux::msvc_eti_base<
-          typename mpl::apply_if<
-              is_convertible<TraversalCategory, random_access_traversal_tag>
-            , mpl::apply_if<
-                  iterator_archetypes::has_access<
-                      AccessCategory
-                    , iterator_archetypes::writable_iterator_t
-                  >
-                , mpl::identity<writable_operator_brackets<Value> >
-                , mpl::if_<
-                      iterator_archetypes::has_access<
-                          AccessCategory
-                        , iterator_archetypes::readable_iterator_t
-                      >
-                    , readable_operator_brackets<Value>
-                    , no_operator_brackets
-                  >
-              >
-            , mpl::identity<no_operator_brackets>
-          >::type
-      >::type
-  {};
-  
-  template <class TraversalCategory>
-  struct traversal_archetype_impl
-  {
-      template <class Derived,class Value> struct archetype;
-  };
-
-  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
-  {};
-
-  template <>
-  struct traversal_archetype_impl<incrementable_traversal_tag>
-  {
-      template<class Derived, class Value>
-      struct archetype
-      {
-          typedef void difference_type;
-
-          Derived& operator++();
-          Derived  operator++(int) const;
-      };
-  };
-
-  template <>
-  struct traversal_archetype_impl<single_pass_traversal_tag>
-  {
-      template<class Derived, class Value>
-      struct archetype
-        : public equality_comparable< traversal_archetype_<Derived, Value, single_pass_traversal_tag> >,
-          public traversal_archetype_<Derived, Value, incrementable_traversal_tag>
-      {
-      };
-  };
-
-  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&);
-  
-#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&);
-#endif 
-  template <>
-  struct traversal_archetype_impl<forward_traversal_tag>
-  {
-      template<class Derived, class Value>
-      struct archetype
-        : public traversal_archetype_<Derived, Value, single_pass_traversal_tag>
-      {
-          typedef std::ptrdiff_t difference_type;
-      };
-  };
-
-  template <>
-  struct traversal_archetype_impl<bidirectional_traversal_tag>
-  {
-      template<class Derived, class Value>
-      struct archetype
-        : public traversal_archetype_<Derived, Value, forward_traversal_tag>
-      {
-          Derived& operator--();
-          Derived  operator--(int) const;
-      };
-  };
-
-  template <>
-  struct traversal_archetype_impl<random_access_traversal_tag>
-  {
-      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> 
-      {
-          Derived& operator+=(std::ptrdiff_t);
-          Derived& operator-=(std::ptrdiff_t);
-      };
-  };
-
-  template <class Derived, class Value>
-  Derived& operator+(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-                     std::ptrdiff_t);
-
-  template <class Derived, class Value>
-  Derived& operator+(std::ptrdiff_t,
-                     traversal_archetype_<Derived, Value, random_access_traversal_tag> const&);
-
-  template <class Derived, class Value>
-  Derived& operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
-                     std::ptrdiff_t);
-
-  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&);
-
-  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&);
-
-  struct bogus_type;
-
-  template <class Value>
-  struct convertible_type
-    : mpl::if_< is_const<Value>,
-                typename remove_const<Value>::type,
-                bogus_type >
-  {};
-
-} // namespace detail
-
-
-template <class> struct undefined;
-  
-template <class AccessCategory>
-struct iterator_access_archetype_impl
-{
-    template <class Value> struct archetype;
-};
-
-template <class Value, class AccessCategory>
-struct iterator_access_archetype
-  : mpl::aux::msvc_eti_base<
-        typename iterator_access_archetype_impl<
-            AccessCategory
-        >::template archetype<Value>
-    >::type
-{
-};
-
-template <>
-struct iterator_access_archetype_impl<
-    iterator_archetypes::readable_iterator_t
->
-{
-    template <class Value>
-    struct archetype
-    {
-        typedef typename remove_cv<Value>::type value_type;
-        typedef Value                           reference;
-        typedef Value*                          pointer;
-
-        value_type operator*() const;
-
-        detail::arrow_proxy<Value> operator->() const;
-    };
-};
-
-template <>
-struct iterator_access_archetype_impl<
-    iterator_archetypes::writable_iterator_t
->
-{
-    template <class Value>
-    struct archetype
-    {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-        BOOST_STATIC_ASSERT(!is_const<Value>::value);
-# endif 
-        typedef void value_type;
-        typedef void reference;
-        typedef void pointer;
-
-        detail::assign_proxy<Value> operator*() const;
-    };
-};
-
-template <>
-struct iterator_access_archetype_impl<
-    iterator_archetypes::readable_writable_iterator_t
->
-{
-    template <class Value>
-    struct archetype
-      : public virtual iterator_access_archetype<
-            Value, iterator_archetypes::readable_iterator_t
-        >
-    {
-        typedef detail::read_write_proxy<Value>    reference;
-
-        detail::read_write_proxy<Value> operator*() const;
-    };
-};
-
-template <>
-struct iterator_access_archetype_impl<iterator_archetypes::readable_lvalue_iterator_t>
-{
-    template <class Value>
-    struct archetype
-      : public virtual iterator_access_archetype<
-            Value, iterator_archetypes::readable_iterator_t
-        >
-    {
-        typedef Value&    reference;
-
-        Value& operator*() const;
-        Value* operator->() const;
-    };
-};
-  
-template <>
-struct iterator_access_archetype_impl<iterator_archetypes::writable_lvalue_iterator_t>
-{
-    template <class Value>
-    struct archetype
-      : public virtual iterator_access_archetype<
-            Value, iterator_archetypes::readable_lvalue_iterator_t
-        >
-    {
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-        BOOST_STATIC_ASSERT((!is_const<Value>::value));
-# endif 
-    };
-};
-  
-
-template <class Value, class AccessCategory, class TraversalCategory>
-struct iterator_archetype;
-  
-template <class Value, class AccessCategory, class TraversalCategory>
-struct traversal_archetype_base 
-  : detail::operator_brackets<
-        typename remove_cv<Value>::type
-      , AccessCategory
-      , TraversalCategory
-    >
-  , detail::traversal_archetype_<
-        iterator_archetype<Value, AccessCategory, TraversalCategory>
-      , Value
-      , TraversalCategory
-    >
-{
-};
-
-namespace detail
-{
-  template <class Value, class AccessCategory, class TraversalCategory>
-  struct iterator_archetype_base
-    : iterator_access_archetype<Value, AccessCategory>
-    , traversal_archetype_base<Value, AccessCategory, TraversalCategory>
-  {
-      typedef iterator_access_archetype<Value, AccessCategory> access;
-      
-      typedef typename detail::facade_iterator_category<
-          TraversalCategory
-        , typename mpl::apply_if<
-              iterator_archetypes::has_access<
-                  AccessCategory, iterator_archetypes::writable_iterator_t
-              >
-            , remove_const<Value>
-            , add_const<Value>
-          >::type
-        , typename access::reference
-      >::type iterator_category;
-
-      // Needed for some broken libraries (see below)
-      typedef boost::iterator<
-          iterator_category
-        , Value
-        , typename traversal_archetype_base<
-              Value, AccessCategory, TraversalCategory
-          >::difference_type
-        , typename access::pointer
-        , typename access::reference
-      > workaround_iterator_base;
-  };
-}
-
-template <class Value, class AccessCategory, class TraversalCategory>
-struct iterator_archetype
-  : public detail::iterator_archetype_base<Value, AccessCategory, TraversalCategory>
-
-    // These broken libraries require derivation from std::iterator
-    // (or related magic) in order to handle iter_swap and other
-    // iterator operations
-# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310)           \
-    || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101))
-  , public detail::iterator_archetype_base<
-        Value, AccessCategory, TraversalCategory
-    >::workaround_iterator_base
-# endif 
-{
-    // Derivation from std::iterator above caused references to nested
-    // types to be ambiguous, so now we have to redeclare them all
-    // here.
-# if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310)           \
-    || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101))
-    
-    typedef detail::iterator_archetype_base<
-        Value,AccessCategory,TraversalCategory
-    > base;
-    
-    typedef typename base::value_type value_type;
-    typedef typename base::reference reference;
-    typedef typename base::pointer pointer;
-    typedef typename base::difference_type difference_type;
-    typedef typename base::iterator_category iterator_category;
-# endif
-
-    iterator_archetype();
-    iterator_archetype(iterator_archetype const&);
-
-    iterator_archetype& operator=(iterator_archetype const&);
-
-    // Optional conversion from mutable
-    // iterator_archetype(iterator_archetype<typename detail::convertible_type<Value>::type, AccessCategory, TraversalCategory> const&);
-};
-
-} // namespace boost
-
-
-#endif // BOOST_ITERATOR_ARCHETYPES_HPP

include/boost/iterator/iterator_categories.hpp

@@ -1,165 +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.
-
-#ifndef BOOST_ITERATOR_CATEGORIES_HPP
-# define BOOST_ITERATOR_CATEGORIES_HPP
-
-# include <boost/config.hpp>
-# include <boost/detail/iterator.hpp>
-# include <boost/iterator/detail/config_def.hpp>
-
-# include <boost/detail/workaround.hpp>
-
-# include <boost/mpl/apply_if.hpp>
-# include <boost/mpl/identity.hpp>
-# include <boost/mpl/placeholders.hpp>
-# include <boost/mpl/aux_/lambda_support.hpp>
-
-# include <boost/type_traits/is_convertible.hpp>
-
-# include <boost/static_assert.hpp>
-
-namespace boost {
-
-//
-// Traversal Categories
-//
-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 {};
-
-namespace detail
-{  
-  //
-  // Convert a "strictly old-style" iterator category to a traversal
-  // tag.  This is broken out into a separate metafunction to reduce
-  // the cost of instantiating iterator_category_to_traversal, below,
-  // for new-style types.
-  //
-  template <class Cat>
-  struct old_category_to_traversal
-    : mpl::apply_if<
-          is_convertible<Cat,std::random_access_iterator_tag>
-        , mpl::identity<random_access_traversal_tag>
-        , mpl::apply_if<
-              is_convertible<Cat,std::bidirectional_iterator_tag>
-            , mpl::identity<bidirectional_traversal_tag>
-            , mpl::apply_if<
-                  is_convertible<Cat,std::forward_iterator_tag>
-                , mpl::identity<forward_traversal_tag>
-                , mpl::apply_if<
-                      is_convertible<Cat,std::input_iterator_tag>
-                    , mpl::identity<single_pass_traversal_tag>
-                    , mpl::apply_if<
-                          is_convertible<Cat,std::output_iterator_tag>
-                        , mpl::identity<incrementable_traversal_tag>
-                        , void
-                      >
-                  >
-              >
-          >
-      >
-  {};
-
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
-  template <>
-  struct old_category_to_traversal<int>
-  {
-      typedef int type;
-  };
-# endif
-
-  template <class Traversal>
-  struct pure_traversal_tag
-    : mpl::apply_if<
-          is_convertible<Traversal,random_access_traversal_tag>
-        , mpl::identity<random_access_traversal_tag>
-        , mpl::apply_if<
-              is_convertible<Traversal,bidirectional_traversal_tag>
-            , mpl::identity<bidirectional_traversal_tag>
-            , mpl::apply_if<
-                  is_convertible<Traversal,forward_traversal_tag>
-                , mpl::identity<forward_traversal_tag>
-                , mpl::apply_if<
-                      is_convertible<Traversal,single_pass_traversal_tag>
-                    , mpl::identity<single_pass_traversal_tag>
-                    , mpl::apply_if<
-                          is_convertible<Traversal,incrementable_traversal_tag>
-                        , mpl::identity<incrementable_traversal_tag>
-                        , void
-                      >
-                  >
-              >
-          >
-      >
-  {
-  };
-  
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
-  template <>
-  struct pure_traversal_tag<int>
-  {
-      typedef int type;
-  };
-# endif
-
-} // namespace detail
-
-
-//
-// Convert an iterator category into a traversal tag
-//
-template <class Cat>
-struct iterator_category_to_traversal
-  : mpl::apply_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>
-    >
-{};
-
-// Trait to get an iterator's traversal category
-template <class Iterator = mpl::_1>
-struct iterator_traversal
-  : iterator_category_to_traversal<
-        typename boost::detail::iterator_traits<Iterator>::iterator_category
-    >
-{};
-
-# ifdef BOOST_MPL_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
-// placeholder. Instead we just specialize it as a metafunction
-// class.
-template <>
-struct iterator_traversal<mpl::_1>
-{
-    template <class T>
-    struct apply : iterator_traversal<T>
-    {};
-};
-template <>
-struct iterator_traversal<mpl::_>
-  : iterator_traversal<mpl::_1>
-{};
-# endif
-
-} // namespace boost
-
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_ITERATOR_CATEGORIES_HPP

include/boost/iterator/iterator_concepts.hpp

@@ -1,381 +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.
-
-#ifndef BOOST_ITERATOR_CONCEPTS_HPP
-#define BOOST_ITERATOR_CONCEPTS_HPP
-
-//  Revision History
-//  26 Apr 2003 thw
-//       Adapted to new iterator concepts
-//  22 Nov 2002 Thomas Witt
-//       Added interoperable concept.
-
-#include <boost/concept_check.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-
-// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems.
-#include <boost/detail/iterator.hpp>
-
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/or.hpp>
-
-#include <boost/static_assert.hpp>
-
-// Use boost/limits to work around missing limits headers on some compilers
-#include <boost/limits.hpp>
-
-#include <algorithm>
-
-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.
-
-  // We use this in place of STATIC_ASSERT((is_convertible<...>))
-  // because some compilers (CWPro7.x) can't detect convertibility.
-  //
-  // Of course, that just gets us a different error at the moment with
-  // some tests, since new iterator category deduction still depends
-  // on convertibility detection. We might need some specializations
-  // to support this compiler.
-  template <class Target, class Source>
-  struct static_assert_base_and_derived
-  {
-      static_assert_base_and_derived(Target* = (Source*)0) {}
-  };
-
-  //===========================================================================
-  // Iterator Access Concepts
-
-  template <typename Iterator>
-  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> >();
-
-      reference r = *i; // or perhaps read(x)
-      value_type v = r;
-      value_type v2 = *i;
-      boost::ignore_unused_variable_warning(v);
-    }
-    Iterator i;
-  };
-  
-  template <
-      typename Iterator
-    , typename ValueType = typename boost::detail::iterator_traits<Iterator>::value_type
-  >
-  class WritableIteratorConcept {
-  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)
-    }
-    ValueType v;
-    Iterator i;
-  };
-  
-  template <typename Iterator>
-  class SwappableIteratorConcept {
-  public:
-
-    void constraints() {
-      std::iter_swap(i1, i2);
-    }
-    Iterator i1;
-    Iterator i2;
-  };
-
-  template <typename Iterator>
-  class ReadableLvalueIteratorConcept
-  {
-   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);
-    }
-    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
-
-  template <typename Iterator>
-  class IncrementableIteratorConcept {
-  public:
-    typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
-
-    void constraints() {
-      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
-      boost::function_requires< 
-        boost::DefaultConstructibleConcept<Iterator> >();
-
-      BOOST_STATIC_ASSERT(
-          (boost::is_convertible<
-                traversal_category
-              , boost::incrementable_traversal_tag
-           >::value
-          ));
-
-      ++i;
-      (void)i++;
-    }
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class SinglePassIteratorConcept {
-  public:
-    typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
-
-    void constraints() {
-      boost::function_requires< IncrementableIteratorConcept<Iterator> >();
-      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
-
-      BOOST_STATIC_ASSERT(
-          (boost::is_convertible<
-                traversal_category
-              , boost::single_pass_traversal_tag
-           >::value
-          ));
-    }
-  };
-
-  template <typename Iterator>
-  class ForwardTraversalConcept {
-  public:
-    typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
-
-    void constraints() {
-      boost::function_requires< SinglePassIteratorConcept<Iterator> >();
-
-      typedef boost::mpl::and_<
-        boost::is_integral<difference_type>,
-        boost::mpl::bool_< std::numeric_limits<difference_type>::is_signed >
-        > difference_type_is_signed_integral;
-
-      BOOST_STATIC_ASSERT(difference_type_is_signed_integral::value);
-      BOOST_STATIC_ASSERT(
-          (boost::is_convertible<
-                traversal_category
-              , boost::forward_traversal_tag
-           >::value
-          ));
-    }
-  };
-  
-  template <typename Iterator>
-  class BidirectionalTraversalConcept {
-  public:
-    typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
-
-    void constraints() {
-      boost::function_requires< ForwardTraversalConcept<Iterator> >();
-      
-      BOOST_STATIC_ASSERT(
-          (boost::is_convertible<
-                traversal_category
-              , boost::bidirectional_traversal_tag
-           >::value
-          ));
-
-      --i;
-      (void)i--;
-    }
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class RandomAccessTraversalConcept {
-  public:
-    typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< BidirectionalTraversalConcept<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;
-  };
-
-  //===========================================================================
-  // Iterator Interoperability Concept
-
-namespace detail
-{
-
-  template <typename TraversalTag>
-  struct Operations;
-    
-  template <>
-  struct Operations<boost::incrementable_traversal_tag>
-  {
-      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>
-      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;
-      }
-    };
-
-  } // namespace detail
-
-  template <typename Iterator, typename ConstIterator>
-  class InteroperableConcept
-  {
-  public:
-    typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    typedef typename boost::iterator_traversal<ConstIterator>::type
-      const_traversal_category;
-    typedef typename boost::detail::iterator_traits<ConstIterator>::difference_type
-      const_difference_type;
-
-    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);
-
-      ci = i;
-
-    }
-    Iterator      i;
-    ConstIterator ci;
-  };
-
-} // namespace boost_concepts
-
-
-#endif // BOOST_ITERATOR_CONCEPTS_HPP

include/boost/iterator/iterator_facade.hpp

@@ -1,589 +0,0 @@
-// (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.
-#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/detail/facade_iterator_category.hpp>
-#include <boost/iterator/detail/enable_if.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/is_convertible.hpp>
-
-#include <boost/mpl/apply_if.hpp>
-#include <boost/mpl/or.hpp>
-
-#include <boost/iterator/detail/config_def.hpp> // this goes last
-
-namespace boost
-{
-  // This forward declaration is required for the friend declaration
-  // in iterator_core_access
-  template <class I, class V, class TC, class R, class D> class iterator_facade;
-
-  namespace detail
-  {
-    //
-    // 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
-      : ::boost::iterators::enable_if<
-           mpl::or_<
-               is_convertible<Facade1, Facade2>
-             , is_convertible<Facade2, Facade1>
-           >
-         , Return
-        >
-#endif
-    {
-#ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-        typedef Return type;
-#endif
-    };
-
-    //
-    // Generates associated types for an iterator_facade with the
-    // given parameters.
-    //
-    template <
-        class ValueParam
-      , class CategoryOrTraversal
-      , class Reference 
-      , class Difference
-    >
-    struct iterator_facade_types
-    {
-        typedef typename facade_iterator_category<
-            CategoryOrTraversal, ValueParam, Reference
-        >::type iterator_category;
-        
-        typedef typename remove_const<ValueParam>::type value_type;
-        
-        typedef typename mpl::apply_if<
-            detail::iterator_writability_disabled<ValueParam,Reference>
-          , add_pointer<typename add_const<value_type>::type>
-          , add_pointer<value_type>
-        >::type pointer;
-      
-# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                          \
-    && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452))              \
-        || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310)))     \
-    || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101))              \
-    || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310)
-
-        // To interoperate with some broken library/compiler
-        // combinations, user-defined iterators must be derived from
-        // std::iterator.  It is possible to implement a standard
-        // library for broken compilers without this limitation.
-#  define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1
-
-        typedef
-           iterator<iterator_category, value_type, Difference, pointer, Reference>
-        base;
-# endif
-    };
-
-
-    // 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
-    {
-        operator_arrow_proxy(T const* px) : m_value(*px) {}
-        const T* operator->() const { return &m_value; }
-        // This function is needed for MWCW and BCC, which won't call operator->
-        // again automatically per 13.3.1.2 para 8
-        operator const T*() const { return &m_value; }
-        T m_value;
-    };
-
-    // 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>
-    struct operator_arrow_result
-    {
-        // CWPro8.3 won't accept "operator_arrow_result::type", and we
-        // need that type below, so metafunction forwarding would be a
-        // losing proposition here.
-        typedef typename mpl::if_<
-            is_reference<Reference>
-          , Pointer
-          , operator_arrow_proxy<Value>
-        >::type type;
-
-        static type make(Reference x)
-        {
-            return type(&x);
-        }
-    };
-
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
-    // Deal with ETI
-    template<>
-    struct operator_arrow_result<int, int, int>
-    {
-        typedef int type;
-    };
-# endif
-
-    //
-    // Iterator is actually an iterator_facade, so we do not have to
-    // go through iterator_traits to access the traits.
-    //
-    template <class Iterator>
-    class operator_brackets_proxy
-    {
-        typedef typename Iterator::reference  reference;
-        typedef typename Iterator::value_type value_type;
-
-     public:
-        operator_brackets_proxy(Iterator const& iter)
-          : m_iter(iter)
-        {}
-
-        operator reference() const
-        {
-            return *m_iter;
-        }
-
-        operator_brackets_proxy& operator=(value_type const& val)
-        {
-            *m_iter = val;
-            return *this;
-        }
-
-     private:
-        Iterator m_iter;
-    };
-
-    template <class Iterator, class Value, class Reference>
-    struct operator_brackets_result
-    {
-        typedef typename mpl::if_<
-            iterator_writability_disabled<Value,Reference>
-          , Value 
-          , operator_brackets_proxy<Iterator>
-        >::type type;
-    };
-
-    template <class Iterator>
-    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::false_)
-    {
-        return operator_brackets_proxy<Iterator>(iter);
-    }
-
-    template <class Iterator>
-    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::true_)
-    {
-      return *iter;
-    }
-
-  } // namespace detail
-
-
-  // Macros which describe the declarations of binary operators
-#  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                                 \
-    >::type                                                             \
-    operator op(                                                        \
-        iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs           \
-      , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)
-
-#  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
-    template <class Derived, class V, class TC, class R, class D>   \
-    prefix Derived operator+ args
-
-  //
-  // Helper class for granting access to the iterator core interface.
-  //
-  // The simple core interface is used by iterator_facade. The core
-  // interface of a user/library defined iterator type should not be made public
-  // so that it does not clutter the public interface. Instead iterator_core_access
-  // should be made friend so that iterator_facade can access the core
-  // interface through iterator_core_access.
-  //
-  class iterator_core_access
-  {
-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-      // Tasteless as this may seem, making all members public allows member templates
-      // to work in the absence of member template friends.
-   public:
-# else
-      
-      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);
-
-      BOOST_ITERATOR_FACADE_RELATION(==)
-      BOOST_ITERATOR_FACADE_RELATION(!=)
-
-      BOOST_ITERATOR_FACADE_RELATION(<)
-      BOOST_ITERATOR_FACADE_RELATION(>)
-      BOOST_ITERATOR_FACADE_RELATION(<=)
-      BOOST_ITERATOR_FACADE_RELATION(>=)
-#  undef BOOST_ITERATOR_FACADE_RELATION
-
-      BOOST_ITERATOR_FACADE_INTEROP_HEAD(
-          friend, -, typename Derived1::difference_type)
-      ;
-
-      BOOST_ITERATOR_FACADE_PLUS_HEAD(
-          friend                                
-          , (iterator_facade<Derived, V, TC, R, D> const&
-           , typename Derived::difference_type)
-      )
-      ;
-
-      BOOST_ITERATOR_FACADE_PLUS_HEAD(
-          friend
-        , (typename Derived::difference_type
-           , iterator_facade<Derived, V, TC, R, D> const&)
-      )
-      ;
-
-# endif
-
-      template <class Facade>
-      static typename Facade::reference dereference(Facade const& f)
-      {
-          return f.dereference();
-      }
-
-      template <class Facade>
-      static void increment(Facade& f)
-      {
-          f.increment();
-      }
-
-      template <class Facade>
-      static void decrement(Facade& f)
-      {
-          f.decrement();
-      }
-
-      template <class Facade1, class Facade2>
-      static bool equal(Facade1 const& f1, Facade2 const& f2)
-      {
-          return f1.equal(f2);
-      }
-
-      template <class Facade>
-      static void advance(Facade& f, typename Facade::difference_type n)
-      {
-          f.advance(n);
-      }
-
-      template <class Facade1, class Facade2>
-      static typename Facade1::difference_type distance_to(
-                                                           Facade1 const& f1, Facade2 const& f2)
-      {
-          return f1.distance_to(f2);
-      }
-
-   private:
-      // objects of this class are useless
-      iterator_core_access(); //undefined
-  };
-
-  //
-  // iterator_facade - use as a public base class for defining new
-  // standard-conforming iterators.
-  //
-  template <
-      class Derived             // The derived iterator type being constructed
-    , class Value
-    , class CategoryOrTraversal
-    , class Reference   = Value&
-    , class Difference  = std::ptrdiff_t
-  >
-  class iterator_facade
-# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
-    : public detail::iterator_facade_types<
-         Value, CategoryOrTraversal, Reference, Difference
-      >::base
-#  undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
-# endif
-  {
-   private:
-      //
-      // Curiously Recurring Template interface.
-      //
-      typedef Derived derived_t;
-
-      Derived& derived()
-      {
-          return static_cast<Derived&>(*this);
-      }
-
-      Derived const& derived() const
-      {
-          return static_cast<Derived const&>(*this);
-      }
-
-      typedef detail::iterator_facade_types<
-         Value, CategoryOrTraversal, Reference, Difference
-      > associated_types;
-      
-   public:
-
-      typedef typename associated_types::value_type value_type;
-      typedef Reference reference;
-      typedef Difference difference_type;
-      typedef typename associated_types::pointer pointer;
-      typedef typename associated_types::iterator_category iterator_category;
-
-      reference operator*() const
-      {
-          return iterator_core_access::dereference(this->derived());
-      }
-
-      typename detail::operator_arrow_result<
-          value_type
-        , reference
-        , pointer
-      >::type
-      operator->() const
-      {
-          return detail::operator_arrow_result<
-              value_type
-            , reference
-            , pointer
-          >::make(*this->derived());
-      }
-        
-      typename detail::operator_brackets_result<Derived,Value,Reference>::type
-      operator[](difference_type n) const
-      {
-          typedef detail::iterator_writability_disabled<Value,Reference>
-              not_writable;
-          
-          return detail::make_operator_brackets_result<Derived>(
-              this->derived() + n
-            , not_writable()
-          );
-      }
-
-      Derived& operator++()
-      {
-          iterator_core_access::increment(this->derived());
-          return this->derived();
-      }
-
-      Derived operator++(int)
-      {
-          Derived tmp(this->derived());
-          ++*this;
-          return tmp;
-      }
-
-      Derived& operator--()
-      {
-          iterator_core_access::decrement(this->derived());
-          return this->derived();
-      }
-
-      Derived operator--(int)
-      {
-          Derived tmp(this->derived());
-          --*this;
-          return tmp;
-      }
-
-      Derived& operator+=(difference_type n)
-      {
-          iterator_core_access::advance(this->derived(), n);
-          return this->derived();
-      }
-
-      Derived& operator-=(difference_type n)
-      {
-          iterator_core_access::advance(this->derived(), -n);
-          return this->derived();
-      }
-
-      Derived operator-(difference_type x) const
-      {
-          Derived result(this->derived());
-          return result -= x;
-      }
-
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
-      // 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
-      // (so far) in STLPort debug mode, but it's clearly a codegen
-      // problem so we apply the workaround for all MSVC6.
-      iterator_facade& operator=(iterator_facade const&)
-      {
-          return *this;
-      }
-# endif
-  };
-
-  //
-  // 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.
-  //
-  // Note though that this kind of interoperability for constant/mutable
-  // iterators is not required by the standard for container iterators.
-  // All the standard asks for is a conversion mutable -> constant.
-  // Most standard library implementations nowadays provide fully interoperable
-  // iterator implementations, but there are still heavily used implementations
-  // that do not provide them. (Actually it's even worse, they do not provide
-  // them for only a few iterators.)
-  //
-  // ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should
-  //    enable the user to turn off mixed type operators
-  //
-  // The library takes care to provide only the right operator overloads.
-  // I.e.
-  //
-  // bool operator==(Iterator,      Iterator);
-  // bool operator==(ConstIterator, Iterator);
-  // bool operator==(Iterator,      ConstIterator);
-  // bool operator==(ConstIterator, ConstIterator);
-  //
-  //   ...
-  //
-  // In order to do so it uses c++ idioms that are not yet widely supported
-  // by current compiler releases. The library is designed to degrade gracefully
-  // in the face of compiler deficiencies. In general compiler
-  // deficiencies result in less strict error checking and more obscure
-  // error messages, functionality is not affected.
-  //
-  // For full operation compiler support for "Substitution Failure Is Not An Error"
-  // (aka. enable_if) and boost::is_convertible is required.
-  //
-  // The following problems occur if support is lacking.
-  //
-  // Pseudo code
-  //
-  // ---------------
-  // AdaptorA<Iterator1> a1;
-  // AdaptorA<Iterator2> a2;
-  //
-  // // This will result in a no such overload error in full operation
-  // // If enable_if or is_convertible is not supported
-  // // The instantiation will fail with an error hopefully indicating that
-  // // there is no operator== for Iterator1, Iterator2
-  // // The same will happen if no enable_if is used to remove
-  // // false overloads from the templated conversion constructor
-  // // of AdaptorA.
-  //
-  // a1 == a2;
-  // ----------------
-  //
-  // AdaptorA<Iterator> a;
-  // AdaptorB<Iterator> b;
-  //
-  // // This will result in a no such overload error in full operation
-  // // If enable_if is not supported the static assert used
-  // // in the operator implementation will fail.
-  // // This will accidently work if is_convertible is not supported.
-  //
-  // a == b;
-  // ----------------
-  //
-
-# 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));            \
-  }
-
-# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
-  BOOST_ITERATOR_FACADE_INTEROP(                                    \
-      op                                                            \
-    , bool                                                          \
-    , true                                                          \
-    , return_prefix                                                 \
-    , base_op                                                       \
-  )
-
-  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)
-# 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)
-    , return
-    , distance_to )
-# undef BOOST_ITERATOR_FACADE_INTEROP
-# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
-
-# define BOOST_ITERATOR_FACADE_PLUS(args)           \
-  BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args)     \
-  {                                                 \
-      Derived tmp(static_cast<Derived const&>(i));  \
-      return tmp += n;                              \
-  }
-
-BOOST_ITERATOR_FACADE_PLUS((
-  iterator_facade<Derived, V, TC, R, D> const& i
-  , typename Derived::difference_type n
-))
-
-BOOST_ITERATOR_FACADE_PLUS((
-    typename Derived::difference_type n
-    , iterator_facade<Derived, V, TC, R, D> const& i
-))
-# undef BOOST_ITERATOR_FACADE_PLUS
-# undef BOOST_ITERATOR_FACADE_PLUS_HEAD
-
-} // namespace boost
-
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP

include/boost/iterator/iterator_traits.hpp

@@ -1,93 +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.
-#ifndef ITERATOR_TRAITS_DWA200347_HPP
-# define ITERATOR_TRAITS_DWA200347_HPP
-
-# include <boost/detail/iterator.hpp>
-# include <boost/detail/workaround.hpp>
-
-namespace boost { 
-
-// Unfortunately, g++ 2.95.x chokes when we define a class template
-// iterator_category which has the same name as its
-// std::iterator_category() function, probably due in part to the
-// "std:: is visible globally" hack it uses.  Use
-// BOOST_ITERATOR_CATEGORY to write code that's portable to older
-// GCCs.
-
-# if BOOST_WORKAROUND(__GNUC__, <= 2)
-#  define BOOST_ITERATOR_CATEGORY iterator_category_
-# else
-#  define BOOST_ITERATOR_CATEGORY iterator_category
-# endif
-
-
-template <class Iterator>
-struct iterator_value
-{
-    typedef typename detail::iterator_traits<Iterator>::value_type type;
-};
-  
-template <class Iterator>
-struct iterator_reference
-{
-    typedef typename detail::iterator_traits<Iterator>::reference type;
-};
-  
-  
-template <class Iterator>
-struct iterator_pointer
-{
-    typedef typename detail::iterator_traits<Iterator>::pointer type;
-};
-  
-template <class Iterator>
-struct iterator_difference
-{
-    typedef typename detail::iterator_traits<Iterator>::difference_type type;
-};
-
-template <class Iterator>
-struct BOOST_ITERATOR_CATEGORY
-{
-    typedef typename detail::iterator_traits<Iterator>::iterator_category type;
-};
-
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
-template <>
-struct iterator_value<int>
-{
-    typedef void type;
-};
-  
-template <>
-struct iterator_reference<int>
-{
-    typedef void type;
-};
-
-template <>
-struct iterator_pointer<int>
-{
-    typedef void type;
-};
-  
-template <>
-struct iterator_difference<int>
-{
-    typedef void type;
-};
-  
-template <>
-struct BOOST_ITERATOR_CATEGORY<int>
-{
-    typedef void type;
-};
-# endif
-
-} // namespace boost::iterator
-
-#endif // ITERATOR_TRAITS_DWA200347_HPP

include/boost/iterator/new_iterator_tests.hpp

@@ -1,214 +0,0 @@
-#ifndef BOOST_NEW_ITERATOR_TESTS_HPP
-# define BOOST_NEW_ITERATOR_TESTS_HPP
-
-// This is meant to be the beginnings of a comprehensive, generic
-// test suite for STL concepts such as iterators and containers.
-//
-// Revision History:
-// 28 Oct 2002  Started update for new iterator categories
-//              (Jeremy Siek)
-// 28 Apr 2002  Fixed input iterator requirements.
-//              For a == b a++ == b++ is no longer required.
-//              See 24.1.1/3 for details.
-//              (Thomas Witt)
-// 08 Feb 2001  Fixed bidirectional iterator test so that
-//              --i is no longer a precondition.
-//              (Jeremy Siek)
-// 04 Feb 2001  Added lvalue test, corrected preconditions
-//              (David Abrahams)
-
-# include <iterator>
-# include <assert.h>
-# include <boost/type_traits.hpp>
-# include <boost/static_assert.hpp>
-# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
-# include <boost/detail/iterator.hpp>
-# include <boost/pending/iterator_tests.hpp>
-# include <boost/iterator/is_readable_iterator.hpp>
-# include <boost/iterator/is_lvalue_iterator.hpp>
-
-# include <boost/iterator/detail/config_def.hpp>
-
-namespace boost {
-
-// Preconditions: *i == v
-template <class Iterator, class T>
-void readable_iterator_test(const Iterator i1, T v)
-{
-  Iterator i2(i1); // Copy Constructible
-  typedef typename detail::iterator_traits<Iterator>::reference ref_t;
-  ref_t r1 = *i1;
-  ref_t r2 = *i2;
-  T v1 = r1;
-  T v2 = r2;
-  assert(v1 == v);
-  assert(v2 == v);
-
-# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
-  // 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);
-# endif 
-}
-
-template <class Iterator, class T>
-void writable_iterator_test(Iterator i, T v)
-{
-  Iterator i2(i); // Copy Constructible
-  *i2 = v;
-}
-
-template <class Iterator>
-void swappable_iterator_test(Iterator i, Iterator j)
-{
-  Iterator i2(i), j2(j);
-  typename detail::iterator_traits<Iterator>::value_type bi = *i, bj = *j;
-  iter_swap(i2, j2);
-  typename detail::iterator_traits<Iterator>::value_type ai = *i, aj = *j;
-  assert(bi == aj && bj == ai);
-}
-
-template <class Iterator, class T>
-void constant_lvalue_iterator_test(Iterator i, T v1)
-{
-  Iterator i2(i);
-  typedef typename detail::iterator_traits<Iterator>::value_type value_type;
-  typedef typename detail::iterator_traits<Iterator>::reference reference;
-  BOOST_STATIC_ASSERT((is_same<const value_type&, reference>::value));
-  const T& v2 = *i2;
-  assert(v1 == v2);
-# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-  BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
-  BOOST_STATIC_ASSERT(!is_non_const_lvalue_iterator<Iterator>::value);
-# endif 
-}
-
-template <class Iterator, class T>
-void non_const_lvalue_iterator_test(Iterator i, T v1, T v2)
-{
-  Iterator i2(i);
-  typedef typename detail::iterator_traits<Iterator>::value_type value_type;
-  typedef typename detail::iterator_traits<Iterator>::reference reference;
-  BOOST_STATIC_ASSERT((is_same<value_type&, reference>::value));
-  T& v3 = *i2;
-  assert(v1 == v3);
-  
-  // A non-const lvalue iterator is not neccessarily writable, but we
-  // are assuming the value_type is assignable here
-  *i = v2;
-  
-  T& v4 = *i2;
-  assert(v2 == v4);
-# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
-  BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
-  BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator<Iterator>::value);
-# endif 
-}
-
-template <class Iterator, class T>
-void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2)
-{
-  Iterator i2;
-  Iterator i3(i);
-  i2 = i;
-  assert(i2 == i3);
-  assert(i != j);
-  assert(i2 != j);
-  readable_iterator_test(i, val1);
-  readable_iterator_test(i2, val1);
-  readable_iterator_test(i3, val1);
-
-  assert(i == i2++);
-  assert(i != ++i3);
-
-  readable_iterator_test(i2, val2);
-  readable_iterator_test(i3, val2);
-
-  readable_iterator_test(i, val1);
-}
-
-template <class Iterator, class T>
-void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2)
-{
-  forward_readable_iterator_test(i, j, val1, val2);
-  Iterator i2 = i;
-  ++i2;
-  swappable_iterator_test(i, i2);
-}
-
-// bidirectional
-// Preconditions: *i == v1, *++i == v2
-template <class Iterator, class T>
-void bidirectional_readable_iterator_test(Iterator i, T v1, T v2)
-{
-  Iterator j(i);
-  ++j;
-  forward_readable_iterator_test(i, j, v1, v2);
-  ++i;
-
-  Iterator i1 = i, i2 = i;
-
-  assert(i == i1--);
-  assert(i != --i2);
-
-  readable_iterator_test(i, v2);
-  readable_iterator_test(i1, v1);
-  readable_iterator_test(i2, v1);
-
-  --i;
-  assert(i == i1);
-  assert(i == i2);
-  ++i1;
-  ++i2;
-
-  readable_iterator_test(i, v1);
-  readable_iterator_test(i1, v2);
-  readable_iterator_test(i2, v2);
-}
-
-// random access
-// Preconditions: [i,i+N) is a valid range
-template <class Iterator, class TrueVals>
-void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals)
-{
-  bidirectional_readable_iterator_test(i, vals[0], vals[1]);
-  const Iterator j = i;
-  int c;
-
-  for (c = 0; c < N-1; ++c)
-  {
-    assert(i == j + c);
-    assert(*i == vals[c]);
-    typename detail::iterator_traits<Iterator>::value_type x = j[c];
-    assert(*i == x);
-    assert(*i == *(j + c));
-    assert(*i == *(c + j));
-    ++i;
-    assert(i > j);
-    assert(i >= j);
-    assert(j <= i);
-    assert(j < i);
-  }
-
-  Iterator k = j + N - 1;
-  for (c = 0; c < N-1; ++c)
-  {
-    assert(i == k - c);
-    assert(*i == vals[N - 1 - c]);
-    typename detail::iterator_traits<Iterator>::value_type x = j[N - 1 - c];
-    assert(*i == x);
-    Iterator q = k - c; 
-    assert(*i == *q);
-    assert(i > j);
-    assert(i >= j);
-    assert(j <= i);
-    assert(j < i);
-    --i;
-  }
-}
-
-} // namespace boost
-
-# include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_NEW_ITERATOR_TESTS_HPP

include/boost/iterator/permutation_iterator.hpp

@@ -1,92 +0,0 @@
-// (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.
-
-#ifndef BOOST_PERMUTATION_ITERATOR_HPP
-#define BOOST_PERMUTATION_ITERATOR_HPP
-
-#include <iterator>
-
-#include <boost/iterator/iterator_adaptor.hpp>
-
-
-namespace boost
-{
-
-template< class ElementIterator
-        , class IndexIterator
-        , class ValueT        = use_default
-        , class CategoryT     = use_default
-        , class ReferenceT    = use_default
-        , class DifferenceT   = use_default >
-class permutation_iterator
-  : public iterator_adaptor< 
-             permutation_iterator<ElementIterator, IndexIterator, ValueT, CategoryT, ReferenceT, DifferenceT>
-           , ElementIterator, ValueT, CategoryT, ReferenceT, DifferenceT >
-{
-  typedef iterator_adaptor< 
-            permutation_iterator<ElementIterator, IndexIterator, ValueT, CategoryT, ReferenceT, DifferenceT>
-          , ElementIterator, ValueT, CategoryT, ReferenceT, DifferenceT > super_t;
-
-  friend class iterator_core_access;
-
-public:
-  permutation_iterator() : order_it_() {}
-
-  explicit permutation_iterator(ElementIterator x, IndexIterator y) 
-      : super_t(x), order_it_(y) {}
-
-  template<class OtherElementIterator, class OtherIndexIterator, class V, class C, class R, class D >
-  permutation_iterator(
-      permutation_iterator<OtherElementIterator, OtherIndexIterator, V, C, R, D> const& r
-      , typename enable_if_convertible<OtherElementIterator, ElementIterator>::type* = 0
-      , typename enable_if_convertible<OtherIndexIterator, IndexIterator>::type* = 0
-      )
-      : super_t(r.base())
-  {}
-
-private:
-    typename super_t::reference dereference() const
-        { return *(this->base() + *this->order_it_); }
-  
-    void increment() { ++this->order_it_; }
-    void decrement() { --this->order_it_; }
-
-    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_;
-};
-
-
-template <class ElementIterator, class IndexIterator>
-permutation_iterator<ElementIterator, IndexIterator> 
-make_permutation_iterator( ElementIterator e, IndexIterator i )
-{
-    return permutation_iterator<ElementIterator, IndexIterator>( e, i );
-}
-
-
-} // namespace boost
-
-#endif

include/boost/iterator/reverse_iterator.hpp

@@ -1,71 +0,0 @@
-// (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.
-#ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP
-#define BOOST_REVERSE_ITERATOR_23022003THW_HPP
-
-#include <boost/iterator.hpp>
-#include <boost/utility.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-
-namespace boost
-{
-
-  //
-  //
-  //
-  template <class Iterator>
-  class reverse_iterator
-      : public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
-  {
-      typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;
-
-      friend class iterator_core_access;
-
-   public:
-      reverse_iterator() {}
-
-      explicit reverse_iterator(Iterator x) 
-          : super_t(x) {}
-
-      template<class OtherIterator>
-      reverse_iterator(
-          reverse_iterator<OtherIterator> const& r
-          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
-          )
-          : super_t(r.base())
-      {}
-
-   private:
-      typename super_t::reference dereference() const { return *boost::prior(this->base()); }
-    
-      void increment() { --this->base_reference(); }
-      void decrement() { ++this->base_reference(); }
-
-      void advance(typename super_t::difference_type n)
-      {
-          this->base_reference() += -n;
-      }
-
-      template <class OtherIterator>
-      typename super_t::difference_type
-      distance_to(reverse_iterator<OtherIterator> const& y) const
-      {
-          return this->base_reference() - y.base();
-      }
-  };
-
-  template <class BidirectionalIterator>
-  reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
-  {
-      return reverse_iterator<BidirectionalIterator>(x);
-  }
-
-} // namespace boost
-
-#endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP

include/boost/iterator/transform_iterator.hpp

@@ -1,170 +0,0 @@
-// (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.
-#ifndef BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
-#define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP
-
-#include <boost/function.hpp>
-#include <boost/iterator.hpp>
-#include <boost/iterator/detail/enable_if.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/function_traits.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_class.hpp>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-#include <boost/iterator/detail/config_def.hpp>
-
-namespace boost
-{
-  template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
-  class transform_iterator;
-
-  namespace detail 
-  {
-
-    template <class UnaryFunction>
-    struct function_object_result
-    {
-      typedef typename UnaryFunction::result_type type;
-    };
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template <class Return, class Argument>
-    struct function_object_result<Return(*)(Argument)>
-    {
-      typedef Return type;
-    };
-#endif
-
-    // Compute the iterator_adaptor instantiation to be used for transform_iterator
-    template <class UnaryFunction, class Iterator, class Reference, class Value>
-    struct transform_iterator_base
-    {
-     private:
-        // By default, dereferencing the iterator yields the same as
-        // the function.  Do we need to adjust the way
-        // function_object_result is computed for the standard
-        // proposal (e.g. using Doug's result_of)?
-        typedef typename ia_dflt_help<
-            Reference
-          , function_object_result<UnaryFunction>
-        >::type reference;
-
-        // To get the default for Value: remove any reference on the
-        // result type, but retain any constness to signal
-        // non-writability.  Note that if we adopt Thomas' suggestion
-        // to key non-writability *only* on the Reference argument,
-        // we'd need to strip constness here as well.
-        typedef typename ia_dflt_help<
-            Value
-          , remove_reference<reference>
-        >::type cv_value_type;
-
-     public:
-        typedef iterator_adaptor<
-            transform_iterator<UnaryFunction, Iterator, Reference, Value>
-          , Iterator
-          , cv_value_type
-          , use_default    // Leave the traversal category alone
-          , reference
-        > type;
-    };
-  }
-
-  template <class UnaryFunction, class Iterator, class Reference, class Value>
-  class transform_iterator
-    : public detail::transform_iterator_base<UnaryFunction, Iterator, Reference, Value>::type
-  {
-    typedef typename
-    detail::transform_iterator_base<UnaryFunction, Iterator, Reference, Value>::type
-    super_t;
-
-    friend class iterator_core_access;
-
-  public:
-    transform_iterator() { }
-
-    transform_iterator(Iterator const& x, UnaryFunction f)
-      : super_t(x), m_f(f) { }
-
-    explicit transform_iterator(Iterator const& x)
-      : super_t(x)
-    {
-        // Pro8 is a little too aggressive about instantiating the
-        // body of this function.
-#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-        // don't provide this constructor if UnaryFunction is a
-        // function pointer type, since it will be 0.  Too dangerous.
-        BOOST_STATIC_ASSERT(is_class<UnaryFunction>::value);
-#endif 
-    }
-
-    template<class OtherIterator>
-    transform_iterator(
-         transform_iterator<UnaryFunction, OtherIterator, Reference, Value> const& t
-       , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
-    )
-      : super_t(t.base()), m_f(t.functor()) {}
-
-    UnaryFunction functor() const
-      { return m_f; }
-
-  private:
-    typename super_t::reference dereference() const
-    { return m_f(*this->base()); }
-
-    // Probably should be the initial base class so it can be
-    // optimized away via EBO if it is an empty class.
-    UnaryFunction m_f;
-  };
-
-  template <class UnaryFunction, class Iterator>
-  transform_iterator<UnaryFunction, Iterator>
-  make_transform_iterator(Iterator it, UnaryFunction fun)
-  {
-      return transform_iterator<UnaryFunction, Iterator>(it, fun);
-  }
-
-  // Version which allows explicit specification of the UnaryFunction
-  // type.
-  //
-  // This generator is not provided if UnaryFunction is a function
-  // pointer type, because it's too dangerous: the default-constructed
-  // function pointer in the iterator be 0, leading to a runtime
-  // crash.
-  template <class UnaryFunction, class Iterator>
-  typename iterators::enable_if<
-      is_class<UnaryFunction>   // We should probably find a cheaper test than is_class<>
-    , transform_iterator<UnaryFunction, Iterator>
-  >::type
-  make_transform_iterator(Iterator it)
-  {
-      return transform_iterator<UnaryFunction, Iterator>(it, UnaryFunction());
-  }
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-  template <class Return, class Argument, class Iterator>
-  transform_iterator< Return (*)(Argument), Iterator, Return>
-  make_transform_iterator(Iterator it, Return (*fun)(Argument))
-  {
-    return transform_iterator<Return (*)(Argument), Iterator, Return>(it, fun);
-  }
-#endif
-
-} // namespace boost
-
-#include <boost/iterator/detail/config_undef.hpp>
-
-#endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP

include/boost/iterator/zip_iterator.hpp

@@ -1,611 +0,0 @@
-// (C) Copyright David Abrahams and Thomas Becker 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.
-//
-// Compilers Tested:
-// =================
-// Metrowerks Codewarrior Pro 7.2, 8.3
-// gcc 2.95.3
-// gcc 3.2
-// Microsoft VC 6sp5 (test fails due to some compiler bug)
-// Microsoft VC 7 (works)
-// Microsoft VC 7.1
-// Intel 5
-// Intel 6
-// Intel 7.1
-// Intel 8
-// Borland 5.5.1 (broken due to lack of support from Boost.Tuples)
-
-#ifndef BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
-
-#include <stddef.h>
-#include <boost/iterator.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/iterator_adaptor.hpp> // for enable_if_convertible
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/detail/iterator.hpp>
-
-#include <boost/iterator/detail/minimum_category.hpp>
-
-#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/lambda.hpp>
-#include <boost/mpl/placeholders.hpp>
-#include <boost/mpl/aux_/lambda_support.hpp>
-
-namespace boost {
-
-  // Zip iterator forward declaration for zip_iterator_base
-  template<typename IteratorTuple>
-  class zip_iterator;
-
-  // One important design goal of the zip_iterator is to isolate all
-  // functionality whose implementation relies on the current tuple
-  // implementation. This goal has been achieved as follows: Inside
-  // the namespace detail there is a namespace tuple_impl_specific.
-  // This namespace encapsulates all functionality that is specific
-  // to the current Boost tuple implementation. More precisely, the
-  // namespace tuple_impl_specific provides the following tuple
-  // algorithms and meta-algorithms for the current Boost tuple
-  // implementation:
-  //
-  // tuple_meta_transform
-  // tuple_meta_accumulate
-  // tuple_transform
-  // tuple_for_each
-  //
-  // If the tuple implementation changes, all that needs to be
-  // replaced is the implementation of these four (meta-)algorithms.
-
-  namespace detail
-  {
-
-    // Functors to be used with tuple algorithms
-    //
-    template<typename DiffType>
-    class advance_iterator
-    {
-    public:
-      advance_iterator(DiffType step) : m_step(step) {}
-      
-      template<typename Iterator>
-      void operator()(Iterator& it) const
-      { it += m_step; }
-
-    private:
-      DiffType m_step;
-    };
-    //
-    struct increment_iterator
-    {
-      template<typename Iterator>
-      void operator()(Iterator& it)
-      { ++it; }
-    };
-    //
-    struct decrement_iterator
-    {
-      template<typename Iterator>
-      void operator()(Iterator& it)
-      { --it; }
-    };
-    //
-    struct dereference_iterator
-    {
-      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
-        type;
-#else 
-        typedef typename
-        iterator_traits<Iterator>::reference
-        type;
-#endif
-      };
-
-      template<typename Iterator>
-        typename apply<Iterator>::type operator()(Iterator& it)
-      { return *it; }
-    };
-           
-
-    // The namespace tuple_impl_specific provides two meta-
-    // algorithms and two algorithms for tuples.
-    //
-    namespace tuple_impl_specific
-    {
-      // Meta-transform algorithm for tuples
-      //
-      template<typename Tuple, class UnaryMetaFun>
-      struct tuple_meta_transform;
-      
-      template<typename Tuple, class UnaryMetaFun>
-      struct tuple_meta_transform_impl
-      {
-          typedef tuples::cons<
-              typename mpl::apply1<
-                  typename mpl::lambda<UnaryMetaFun>::type
-                , typename Tuple::head_type
-              >::type
-            , typename tuple_meta_transform<
-                  typename Tuple::tail_type
-                , UnaryMetaFun 
-              >::type
-          > type;
-      };
-
-      template<typename Tuple, class UnaryMetaFun>
-      struct tuple_meta_transform
-        : mpl::apply_if<
-              boost::is_same<Tuple, tuples::null_type>
-            , mpl::identity<tuples::null_type>
-            , tuple_meta_transform_impl<Tuple, UnaryMetaFun>
-        >
-      {
-      };
-      
-      // Meta-accumulate algorithm for tuples. Note: The template 
-      // parameter StartType corresponds to the initial value in 
-      // ordinary accumulation.
-      //
-      template<class Tuple, class BinaryMetaFun, class StartType>
-      struct tuple_meta_accumulate;
-      
-      template<
-          typename Tuple
-        , class BinaryMetaFun
-        , typename StartType
-      >
-      struct tuple_meta_accumulate_impl
-      {
-         typedef typename mpl::apply2<
-             typename mpl::lambda<BinaryMetaFun>::type
-           , typename Tuple::head_type
-           , typename tuple_meta_accumulate<
-                 typename Tuple::tail_type
-               , BinaryMetaFun
-               , StartType 
-             >::type
-         >::type type;
-      };
-
-      template<
-          typename Tuple
-        , class BinaryMetaFun
-        , typename StartType
-      >
-      struct tuple_meta_accumulate
-        : mpl::apply_if<
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
-              mpl::or_<
-#endif 
-                  boost::is_same<Tuple, tuples::null_type>
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
-                , boost::is_same<Tuple,int>
-              >
-#endif 
-            , mpl::identity<StartType>
-            , tuple_meta_accumulate_impl<
-                  Tuple
-                , BinaryMetaFun
-                , StartType
-              >
-          >
-      {
-      };  
-
-#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)                            \
-    || (                                                                    \
-      BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, != 0) && defined(_MSC_VER)  \
-    )
-// Not sure why intel's partial ordering fails in this case, but I'm
-// assuming int's an MSVC bug-compatibility feature.
-      
-# define BOOST_TUPLE_ALGO_DISPATCH
-# define BOOST_TUPLE_ALGO(algo) algo##_impl
-# define BOOST_TUPLE_ALGO_TERMINATOR , int
-# define BOOST_TUPLE_ALGO_RECURSE , ...
-#else 
-# define BOOST_TUPLE_ALGO(algo) algo
-# define BOOST_TUPLE_ALGO_TERMINATOR
-# define BOOST_TUPLE_ALGO_RECURSE
-#endif
-      
-      // transform algorithm for tuples. The template parameter Fun
-      // must be a unary functor which is also a unary metafunction
-      // class that computes its return type based on its argument
-      // type. For example:
-      //
-      // struct to_ptr
-      // {
-      //     template <class Arg>
-      //     struct apply
-      //     {
-      //          typedef Arg* type;
-      //     }
-      //
-      //     template <class Arg>
-      //     Arg* operator()(Arg x);
-      // };
-      template<typename Fun>
-      tuples::null_type BOOST_TUPLE_ALGO(tuple_transform)
-          (tuples::null_type const&, Fun BOOST_TUPLE_ALGO_TERMINATOR)
-      { return tuples::null_type(); }
-
-      template<typename Tuple, typename Fun>
-      typename tuple_meta_transform<
-          Tuple
-        , Fun
-      >::type
-      
-      BOOST_TUPLE_ALGO(tuple_transform)(
-        const Tuple& t, 
-        Fun f
-        BOOST_TUPLE_ALGO_RECURSE
-      )
-      { 
-          typedef typename tuple_meta_transform<
-              BOOST_DEDUCED_TYPENAME Tuple::tail_type
-            , Fun
-          >::type transformed_tail_type;
-
-        return tuples::cons<
-            BOOST_DEDUCED_TYPENAME mpl::apply1<
-                Fun, BOOST_DEDUCED_TYPENAME Tuple::head_type
-             >::type
-           , transformed_tail_type
-        >( 
-            f(boost::tuples::get<0>(t)), tuple_transform(t.get_tail(), f)
-        );
-      }
-
-#ifdef BOOST_TUPLE_ALGO_DISPATCH
-      template<typename Tuple, typename Fun>
-      typename tuple_meta_transform<
-          Tuple
-        , Fun
-      >::type
-      
-      tuple_transform(
-        const Tuple& t, 
-        Fun f
-      )
-      {
-          return tuple_transform_impl(t, f, 1);
-      }
-#endif
-      
-      // for_each algorithm for tuples.
-      //
-      template<typename Fun>
-      Fun BOOST_TUPLE_ALGO(tuple_for_each)(
-          tuples::null_type
-        , Fun f BOOST_TUPLE_ALGO_TERMINATOR
-      )
-      { return f; }
-
-      
-      template<typename Tuple, typename Fun>
-      Fun BOOST_TUPLE_ALGO(tuple_for_each)(
-          Tuple& t
-        , Fun f BOOST_TUPLE_ALGO_RECURSE)
-      { 
-          f( t.get_head() );
-          return tuple_for_each(t.get_tail(), f);
-      }
-      
-#ifdef BOOST_TUPLE_ALGO_DISPATCH
-      template<typename Tuple, typename Fun>
-      Fun
-      tuple_for_each(
-        Tuple& t, 
-        Fun f
-      )
-      {
-          return tuple_for_each_impl(t, f, 1);
-      }
-#endif
-      
-      // Equality of tuples. NOTE: "==" for tuples currently (7/2003)
-      // has problems under some compilers, so I just do my own.
-      // No point in bringing in a bunch of #ifdefs here. This is
-      // going to go away with the next tuple implementation anyway.
-      //
-      bool tuple_equal(tuples::null_type, tuples::null_type)
-      { return true; }
-
-      template<typename Tuple1, typename Tuple2>
-        bool tuple_equal(
-            Tuple1 const& t1, 
-            Tuple2 const& t2
-        )
-      { 
-          return t1.get_head() == t2.get_head() && 
-          tuple_equal(t1.get_tail(), t2.get_tail());
-      }
-    }
-    //
-    // end namespace tuple_impl_specific
-
-    template<typename Iterator>
-    struct iterator_reference
-    {
-        typedef typename iterator_traits<Iterator>::reference type;
-    };
-
-#ifdef BOOST_MPL_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
-    // placeholder. Instead we just specialize it as a metafunction
-    // class.
-    template<>
-    struct iterator_reference<mpl::_1>
-    {
-        template <class T>
-        struct apply : iterator_reference<T> {};
-    };
-#endif
-    
-    // Metafunction to obtain the type of the tuple whose element types
-    // are the reference types of an iterator tuple.
-    //
-    template<typename IteratorTuple>
-    struct tuple_of_references
-      : tuple_impl_specific::tuple_meta_transform<
-            IteratorTuple, 
-            iterator_reference<mpl::_1>
-          >
-    {
-    };
-
-    // Metafunction to obtain the minimal traversal tag in a tuple
-    // of iterators.
-    //
-    template<typename IteratorTuple>
-    struct minimum_traversal_category_in_iterator_tuple
-    {
-      typedef typename tuple_impl_specific::tuple_meta_transform<
-          IteratorTuple
-        , iterator_traversal<>
-      >::type tuple_of_traversal_tags;
-          
-      typedef typename tuple_impl_specific::tuple_meta_accumulate<
-          tuple_of_traversal_tags
-        , minimum_category<>
-        , random_access_traversal_tag
-      >::type type;
-    };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200) // ETI workaround
-      template <>
-      struct minimum_traversal_category_in_iterator_tuple<int>
-      {
-          typedef int type;
-      };
-#endif
-      
-      // We need to call tuple_meta_accumulate with mpl::and_ as the
-      // accumulating functor. To this end, we need to wrap it into
-      // a struct that has exactly two arguments (that is, template
-      // parameters) and not five, like mpl::and_ does.
-      //
-      template<typename Arg1, typename Arg2>
-      struct and_with_two_args
-        : mpl::and_<Arg1, Arg2>
-      {
-      };
-    
-# ifdef BOOST_MPL_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<>
-      struct and_with_two_args<mpl::_1,mpl::_2>
-      {
-          template <class A1, class A2>
-          struct apply : mpl::and_<A1,A2>
-          {};
-      };
-# endif 
-
-    ///////////////////////////////////////////////////////////////////
-    //
-    // Class zip_iterator_base
-    //
-    // Builds and exposes the iterator facade type from which the zip 
-    // iterator will be derived.
-    //
-    template<typename IteratorTuple>
-    struct zip_iterator_base
-    {
-     private:
-        // Reference type is the type of the tuple obtained from the
-        // iterators' reference types.
-        typedef typename 
-        detail::tuple_of_references<IteratorTuple>::type reference;
-      
-        // Value type is the same as reference type.
-        typedef reference value_type;
-      
-        // Difference type is the first iterator's difference type
-        typedef typename iterator_traits<
-            typename tuples::element<0, IteratorTuple>::type
-            >::difference_type difference_type;
-      
-        // Traversal catetgory is the minimum traversal category in the 
-        // iterator tuple.
-        typedef typename 
-        detail::minimum_traversal_category_in_iterator_tuple<
-            IteratorTuple
-        >::type traversal_category;
-     public:
-      
-        // The iterator facade type from which the zip iterator will
-        // be derived.
-        typedef iterator_facade<
-            zip_iterator<IteratorTuple>,
-            value_type,  
-            traversal_category,
-            reference,
-            difference_type
-        > type;
-    };
-
-    template <>
-    struct zip_iterator_base<int>
-    {
-        typedef int type;
-    };
-  }
-  
-  /////////////////////////////////////////////////////////////////////
-  //
-  // zip_iterator class definition
-  //
-  template<typename IteratorTuple>
-  class zip_iterator : 
-    public detail::zip_iterator_base<IteratorTuple>::type
-  {  
-
-   // Typedef super_t as our base class. 
-   typedef typename 
-     detail::zip_iterator_base<IteratorTuple>::type super_t;
-
-   // iterator_core_access is the iterator's best friend.
-   friend class iterator_core_access;
-
-  public:
-    
-    // Construction
-    // ============
-    
-    // Default constructor
-    zip_iterator() { }
-
-    // Constructor from iterator tuple
-    zip_iterator(IteratorTuple iterator_tuple) 
-      : m_iterator_tuple(iterator_tuple) 
-    { }
-
-    // Copy constructor
-    template<typename OtherIteratorTuple>
-    zip_iterator(
-       const zip_iterator<OtherIteratorTuple>& other,
-       typename enable_if_convertible<
-         OtherIteratorTuple,
-         IteratorTuple
-         >::type* = 0
-    ) : m_iterator_tuple(other.get_iterator_tuple())
-    {}
-
-    // Get method for the iterator tuple.
-    const IteratorTuple& get_iterator_tuple() const
-    { return m_iterator_tuple; }
-
-  private:
-    
-    // Implementation of Iterator Operations
-    // =====================================
-    
-    // Dereferencing returns a tuple built from the dereferenced
-    // iterators in the iterator tuple.
-    typename super_t::reference dereference() const
-    { 
-      return detail::tuple_impl_specific::tuple_transform( 
-        get_iterator_tuple(),
-        detail::dereference_iterator()
-       );
-    }
-
-    // Two zip iterators are equal if all iterators in the iterator
-    // tuple are equal. NOTE: It should be possible to implement this
-    // as
-    //
-    // return get_iterator_tuple() == other.get_iterator_tuple();
-    //
-    // but equality of tuples currently (7/2003) does not compile
-    // under several compilers. No point in bringing in a bunch
-    // of #ifdefs here.
-    //
-    template<typename OtherIteratorTuple>   
-    bool equal(const zip_iterator<OtherIteratorTuple>& other) const
-    {
-      return detail::tuple_impl_specific::tuple_equal(
-        get_iterator_tuple(),
-        other.get_iterator_tuple()
-        );
-    }
-
-    // Advancing a zip iterator means to advance all iterators in the
-    // iterator tuple.
-    void advance(typename super_t::difference_type n)
-    { 
-      detail::tuple_impl_specific::tuple_for_each(
-          m_iterator_tuple,
-          detail::advance_iterator<BOOST_DEDUCED_TYPENAME super_t::difference_type>(n)
-          );
-    }
-    // Incrementing a zip iterator means to increment all iterators in
-    // the iterator tuple.
-    void increment()
-    { 
-      detail::tuple_impl_specific::tuple_for_each(
-        m_iterator_tuple,
-        detail::increment_iterator()
-        );
-    }
-    
-    // Decrementing a zip iterator means to decrement all iterators in
-    // the iterator tuple.
-    void decrement()
-    { 
-      detail::tuple_impl_specific::tuple_for_each(
-        m_iterator_tuple,
-        detail::decrement_iterator()
-        );
-    }
-    
-    // Distance is calculated using the first iterator in the tuple.
-    template<typename OtherIteratorTuple>
-      typename super_t::difference_type distance_to(
-        const zip_iterator<OtherIteratorTuple>& other
-        ) const
-    { 
-        return boost::tuples::get<0>(other.get_iterator_tuple()) - 
-            boost::tuples::get<0>(this->get_iterator_tuple());
-    }
-  
-    // Data Members
-    // ============
-    
-    // The iterator tuple.
-    IteratorTuple m_iterator_tuple;
- 
-  };
-
-  // Make function for zip iterator
-  //
-  template<typename IteratorTuple> 
-  zip_iterator<IteratorTuple> 
-  make_zip_iterator(IteratorTuple t)
-  { return zip_iterator<IteratorTuple>(t); }
-
-}
-
-#endif

include/boost/iterator_adaptors.hpp

@@ -1,13 +0,0 @@
-// 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
-
-#define BOOST_ITERATOR_ADAPTORS_VERSION 0x0200
-#include <boost/iterator/iterator_adaptor.hpp>
-
-#endif // BOOST_ITERATOR_ADAPTOR_13062003HK_HPP

include/boost/pending/detail/int_iterator.hpp

@@ -1,75 +0,0 @@
-//  (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.
-
-#ifndef BOOST_INT_ITERATOR_H
-#define BOOST_INT_ITERATOR_H
-
-#include <boost/iterator.hpp>
-#if !defined BOOST_MSVC
-#include <boost/operators.hpp>
-#endif
-#include <iostream>
-//using namespace std;
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-namespace boost {
-#endif
-
-// this should use random_access_iterator_helper but I've had
-// VC++ portablility problems with that. -JGS
-template <class IntT>
-class int_iterator
-{
-  typedef int_iterator self;
-public:
-  typedef std::random_access_iterator_tag iterator_category;
-  typedef IntT value_type;
-  typedef IntT& reference;
-  typedef IntT* pointer;
-  typedef std::ptrdiff_t difference_type;
-
-  inline int_iterator() : _i(0) { }
-  inline int_iterator(IntT i) : _i(i) { }
-  inline int_iterator(const self& x) : _i(x._i) { }
-  inline self& operator=(const self& x) { _i = x._i; return *this; }
-  inline IntT operator*() { return _i; }
-  inline IntT operator[](IntT n) { return _i + n; }
-  inline self& operator++() { ++_i; return *this; }
-  inline self operator++(int) { self t = *this; ++_i; return t; }
-  inline self& operator+=(IntT n) { _i += n; return *this; }
-  inline self operator+(IntT n) { self t = *this; t += n; return t; }
-  inline self& operator--() { --_i; return *this; }
-  inline self operator--(int) { self t = *this; --_i; return t; }
-  inline self& operator-=(IntT n) { _i -= n; return *this; }
-  inline IntT operator-(const self& x) const { return _i - x._i; }
-  inline bool operator==(const self& x) const { return _i == x._i; }
-  // vc++ had a problem finding != in random_access_iterator_helper
-  // need to look into this... for now implementing everything here -JGS
-  inline bool operator!=(const self& x) const { return _i != x._i; }
-  inline bool operator<(const self& x) const { return _i < x._i; }
-  inline bool operator<=(const self& x) const { return _i <= x._i; }
-  inline bool operator>(const self& x) const { return _i > x._i; }
-  inline bool operator>=(const self& x) const { return _i >= x._i; }
-protected:
-  IntT _i;
-};
-
-template <class IntT>
-inline int_iterator<IntT>
-operator+(IntT n, int_iterator<IntT> t) { t += n; return t; }
-
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
-} /* namespace boost */
-#endif
-
-#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
-namespace boost {
-  using ::int_iterator;
-}
-#endif
-
-
-#endif /* BOOST_INT_ITERATOR_H */

include/boost/pending/integer_range.hpp

@@ -1,59 +0,0 @@
-// (C) Copyright David Abrahams and Jeremy Siek 2000-2001. Permission to copy,
-// use, modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided "as is"
-// without express or implied warranty, and with no claim as to its suitability
-// for any purpose.
-//
-// Revision History:
-// 04 Jan 2001  Factored counting_iterator stuff into
-//              boost/counting_iterator.hpp (David Abrahams)
-
-#ifndef BOOST_INTEGER_RANGE_HPP_
-#define BOOST_INTEGER_RANGE_HPP_
-
-#include <boost/config.hpp>
-#include <boost/iterator/counting_iterator.hpp>
-
-namespace boost {
-
-//=============================================================================
-// Counting Iterator and Integer Range Class
-
-template <class IntegerType>
-struct integer_range {
-    typedef counting_iterator<IntegerType> iterator;
-
-    typedef iterator const_iterator;
-    typedef IntegerType value_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef IntegerType reference;
-    typedef IntegerType const_reference;
-    typedef const IntegerType* pointer;
-    typedef const IntegerType* const_pointer;
-    typedef IntegerType size_type;
-
-    integer_range(IntegerType start, IntegerType finish)
-        : m_start(start), m_finish(finish) { }
-
-    iterator begin() const { return iterator(m_start); }
-    iterator end() const { return iterator(m_finish); }
-    size_type size() const { return m_finish - m_start; }
-    bool empty() const { return m_finish == m_start; }
-    void swap(integer_range& x) {
-        std::swap(m_start, x.m_start);
-        std::swap(m_finish, x.m_finish);
-    }
-protected:
-    IntegerType m_start, m_finish;
-};
-
-template <class IntegerType>
-inline integer_range<IntegerType>
-make_integer_range(IntegerType first, IntegerType last)
-{
-  return integer_range<IntegerType>(first, last);
-}
-
-} // namespace boost
-
-#endif // BOOST_INTEGER_RANGE_HPP_

include/boost/pending/iterator_adaptors.hpp

@@ -1,7 +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.
-
-#include <boost/iterator_adaptors.hpp>

include/boost/pending/iterator_tests.hpp

@@ -1,269 +0,0 @@
-// 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.
-#ifndef BOOST_ITERATOR_TESTS_HPP
-# define BOOST_ITERATOR_TESTS_HPP
-
-// This is meant to be the beginnings of a comprehensive, generic
-// test suite for STL concepts such as iterators and containers.
-//
-// Revision History:
-// 28 Apr 2002  Fixed input iterator requirements.
-//              For a == b a++ == b++ is no longer required.
-//              See 24.1.1/3 for details.
-//              (Thomas Witt)
-// 08 Feb 2001  Fixed bidirectional iterator test so that
-//              --i is no longer a precondition.
-//              (Jeremy Siek)
-// 04 Feb 2001  Added lvalue test, corrected preconditions
-//              (David Abrahams)
-
-# include <iterator>
-# include <assert.h>
-# include <boost/type_traits.hpp>
-# include <boost/static_assert.hpp>
-# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
-# include <boost/implicit_cast.hpp>
-# include <boost/type_traits/broken_compiler_spec.hpp>
-
-namespace boost {
-
-  // use this for the value type
-struct dummyT { 
-  dummyT() { }
-  dummyT(detail::dummy_constructor) { }
-  dummyT(int x) : m_x(x) { }
-  int foo() const { return m_x; } 
-  bool operator==(const dummyT& d) const { return m_x == d.m_x; }
-  int m_x;
-};
-
-}
-
-BOOST_TT_BROKEN_COMPILER_SPEC(boost::dummyT)
-    
-namespace boost {
-
-// Tests whether type Iterator satisfies the requirements for a
-// TrivialIterator. 
-// Preconditions: i != j, *i == val
-template <class Iterator, class T>
-void trivial_iterator_test(const Iterator i, const Iterator j, T val)
-{
-  Iterator k;
-  assert(i == i);
-  assert(j == j);
-  assert(i != j);
-#ifdef BOOST_NO_STD_ITERATOR_TRAITS
-  T v = *i;
-#else
-  typename std::iterator_traits<Iterator>::value_type v = *i;
-#endif
-  assert(v == val);
-#if 0
-  // hmm, this will give a warning for transform_iterator...  perhaps
-  // this should be separated out into a stand-alone test since there
-  // are several situations where it can't be used, like for
-  // integer_range::iterator.
-  assert(v == i->foo());
-#endif
-  k = i;
-  assert(k == k);
-  assert(k == i);
-  assert(k != j);
-  assert(*k == val);
-}
-
-
-// Preconditions: i != j
-template <class Iterator, class T>
-void mutable_trivial_iterator_test(const Iterator i, const Iterator j, T val)
-{
-  *i = val;
-  trivial_iterator_test(i, j, val);
-}
-
-
-// Preconditions: *i == v1, *++i == v2
-template <class Iterator, class T>
-void input_iterator_test(Iterator i, T v1, T v2) 
-{
-  Iterator i1(i);
-
-  assert(i == i1);
-  assert(!(i != i1));
-
-  // I can see no generic way to create an input iterator
-  // that is in the domain of== of i and != i.
-  // The following works for istream_iterator but is not
-  // guaranteed to work for arbitrary input iterators.
-  //
-  //   Iterator i2;
-  //
-  //   assert(i != i2);
-  //   assert(!(i == i2));
-
-  assert(*i1 == v1);
-  assert(*i  == v1);
-
-  // we cannot test for equivalence of (void)++i & (void)i++
-  // as i is only guaranteed to be single pass.
-  assert(*i++ == v1);
-
-  i1 = i;
-
-  assert(i == i1);
-  assert(!(i != i1));
-
-  assert(*i1 == v2);
-  assert(*i  == v2);
-
-  // i is dereferencable, so it must be incrementable.
-  ++i;
-
-  // how to test for operator-> ?
-}
-
-// how to test output iterator?
-
-
-template <bool is_pointer> struct lvalue_test
-{
-    template <class Iterator> static void check(Iterator)
-    {
-# ifndef BOOST_NO_STD_ITERATOR_TRAITS
-        typedef typename std::iterator_traits<Iterator>::reference reference;
-        typedef typename std::iterator_traits<Iterator>::value_type value_type;
-# else
-        typedef typename Iterator::reference reference;
-        typedef typename Iterator::value_type value_type;
-# endif
-        BOOST_STATIC_ASSERT(boost::is_reference<reference>::value);
-        BOOST_STATIC_ASSERT((boost::is_same<reference,value_type&>::value
-                             || boost::is_same<reference,const value_type&>::value
-            ));
-    }
-};
-
-# ifdef BOOST_NO_STD_ITERATOR_TRAITS
-template <> struct lvalue_test<true> {
-    template <class T> static void check(T) {}
-};
-#endif
-
-template <class Iterator, class T>
-void forward_iterator_test(Iterator i, T v1, T v2) 
-{
-  input_iterator_test(i, v1, v2);
-
-  Iterator i1 = i, i2 = i;
-
-  assert(i == i1++);
-  assert(i != ++i2);
-
-  trivial_iterator_test(i, i1, v1);
-  trivial_iterator_test(i, i2, v1);
-
-  ++i;
-  assert(i == i1);
-  assert(i == i2);
-  ++i1;
-  ++i2;
-
-  trivial_iterator_test(i, i1, v2);
-  trivial_iterator_test(i, i2, v2);
-
- // borland doesn't allow non-type template parameters
-# if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
-  lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);
-#endif
-}
-
-// Preconditions: *i == v1, *++i == v2
-template <class Iterator, class T>
-void bidirectional_iterator_test(Iterator i, T v1, T v2)
-{
-  forward_iterator_test(i, v1, v2);
-  ++i;
-
-  Iterator i1 = i, i2 = i;
-
-  assert(i == i1--);
-  assert(i != --i2);
-
-  trivial_iterator_test(i, i1, v2);
-  trivial_iterator_test(i, i2, v2);
-
-  --i;
-  assert(i == i1);
-  assert(i == i2);
-  ++i1;
-  ++i2;
-
-  trivial_iterator_test(i, i1, v1);
-  trivial_iterator_test(i, i2, v1);
-}
-
-// mutable_bidirectional_iterator_test
-
-template <class U> struct undefined;
-
-// Preconditions: [i,i+N) is a valid range
-template <class Iterator, class TrueVals>
-void random_access_iterator_test(Iterator i, int N, TrueVals vals)
-{
-  bidirectional_iterator_test(i, vals[0], vals[1]);
-  const Iterator j = i;
-  int c;
-
-  typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
-  
-  for (c = 0; c < N-1; ++c) {
-    assert(i == j + c);
-    assert(*i == vals[c]);
-    assert(*i == boost::implicit_cast<value_type>(j[c]));
-    assert(*i == *(j + c));
-    assert(*i == *(c + j));
-    ++i;
-    assert(i > j);
-    assert(i >= j);
-    assert(j <= i);
-    assert(j < i);
-  }
-
-  Iterator k = j + N - 1;
-  for (c = 0; c < N-1; ++c) {
-    assert(i == k - c);
-    assert(*i == vals[N - 1 - c]);
-    assert(*i == boost::implicit_cast<value_type>(j[N - 1 - c]));
-    Iterator q = k - c; 
-    assert(*i == *q);
-    assert(i > j);
-    assert(i >= j);
-    assert(j <= i);
-    assert(j < i);
-    --i;
-  }
-}
-
-// Precondition: i != j
-template <class Iterator, class ConstIterator>
-void const_nonconst_iterator_test(Iterator i, ConstIterator j)
-{
-  assert(i != j);
-  assert(j != i);
-
-  ConstIterator k(i);
-  assert(k == i);
-  assert(i == k);
-
-  k = i;
-  assert(k == i);
-  assert(i == k);
-}
-
-} // namespace boost
-
-#endif // BOOST_ITERATOR_TESTS_HPP

include/boost/shared_container_iterator.hpp

@@ -1,62 +0,0 @@
-// (C) Copyright Ronald Garcia 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.
-
-// See http://www.boost.org/libs/utility/shared_container_iterator.html for documentation.
-
-#ifndef SHARED_CONTAINER_ITERATOR_RG08102002_HPP
-#define SHARED_CONTAINER_ITERATOR_RG08102002_HPP
-
-#include "boost/iterator_adaptors.hpp"
-#include "boost/shared_ptr.hpp"
-#include <utility>
-
-namespace boost {
-
-template <typename Container>
-class shared_container_iterator : public iterator_adaptor<
-                                    shared_container_iterator<Container>,
-                                    typename Container::iterator> {
-
-  typedef iterator_adaptor<
-    shared_container_iterator<Container>,
-    typename Container::iterator> super_t;
-
-  typedef typename Container::iterator iterator_t;
-  typedef boost::shared_ptr<Container> container_ref_t;
-
-  container_ref_t container_ref;
-public:
-  shared_container_iterator() { }
-
-  shared_container_iterator(iterator_t const& x,container_ref_t const& c) :
-    super_t(x), container_ref(c) { }
-
-
-};
-
-template <typename Container>
-shared_container_iterator<Container>
-make_shared_container_iterator(typename Container::iterator iter,
-			       boost::shared_ptr<Container> const& container) {
-  typedef shared_container_iterator<Container> iterator;
-  return iterator(iter,container);
-}
-
-
-
-template <typename Container>
-std::pair<
-  shared_container_iterator<Container>,
-  shared_container_iterator<Container> >
-make_shared_container_range(boost::shared_ptr<Container> const& container) {
-  return
-    std::make_pair(
-      make_shared_container_iterator(container->begin(),container),
-      make_shared_container_iterator(container->end(),container));
-}
-
-
-} // namespace boost
-#endif  // SHARED_CONTAINER_ITERATOR_RG08102002_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;
-}