bcbboost branch rebased on current release

[SVN r49389]

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

@@ -40,7 +40,7 @@ Lab</a>, <a class="reference external" href="http://www.styleadvisor.com">Zephyr
 <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 external" href="../../../more/generic_programming.html#concept">concepts</a> which extend the C++ standard
+is a system of <a class="reference external" href="http://www.boost.org/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
@@ -179,7 +179,7 @@ implement iterators, you probably wrote a <tt class="docutils literal"><span cla
 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 external" href="../../../more/generic_programming.html#type_generator">type generator</a> to build the
+you probably wrote a <a class="reference external" href="http://www.boost.org/more/generic_programming.html#type_generator">type generator</a> to build the
 <tt class="docutils literal"><span class="pre">iterator_adaptor</span></tt> specialization you needed; in the new library
 design you don't need a type generator (though may want to keep it
 around as a compatibility aid for older code) because, due to the

doc/index.rst

@@ -43,7 +43,7 @@ __ ../../../index.htm
            The components of the Boost Iterator Library replace the
            older Boost Iterator Adaptor Library.
 
-.. _concepts: ../../../more/generic_programming.html#concept
+.. _concepts: http://www.boost.org/more/generic_programming.html#concept
 
 .. contents:: **Table of Contents**
 
@@ -271,7 +271,7 @@ 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
+.. _`type generator`: http://www.boost.org/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

doc/issues.html

@@ -0,0 +1,451 @@
+<?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.4: http://docutils.sourceforge.net/" />
+<title>Problem with is_writable and is_swappable in N1550</title>
+<meta name="author" content="David Abrahams and Jeremy Siek" />
+<meta name="organization" content="Boost Consulting, Indiana University Bloomington" />
+<meta name="date" content="2003-11-19" />
+<meta name="copyright" content="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)" />
+<style type="text/css">
+
+/*
+:Author: David Goodger
+:Contact: goodger@users.sourceforge.net
+:Date: $Date$
+:Revision: $Revision$
+:Copyright: This stylesheet has been placed in the public domain.
+
+Default cascading style sheet for the HTML output of Docutils.
+
+See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
+customize this style sheet.
+*/
+
+/* used to remove borders from tables and images */
+.borderless, table.borderless td, table.borderless th {
+  border: 0 }
+
+table.borderless td, table.borderless th {
+  /* Override padding for "table.docutils td" with "! important".
+     The right padding separates the table cells. */
+  padding: 0 0.5em 0 0 ! important }
+
+.first {
+  /* Override more specific margin styles with "! important". */
+  margin-top: 0 ! important }
+
+.last, .with-subtitle {
+  margin-bottom: 0 ! important }
+
+.hidden {
+  display: none }
+
+a.toc-backref {
+  text-decoration: none ;
+  color: black }
+
+blockquote.epigraph {
+  margin: 2em 5em ; }
+
+dl.docutils dd {
+  margin-bottom: 0.5em }
+
+/* Uncomment (and remove this text!) to get bold-faced definition list terms
+dl.docutils dt {
+  font-weight: bold }
+*/
+
+div.abstract {
+  margin: 2em 5em }
+
+div.abstract p.topic-title {
+  font-weight: bold ;
+  text-align: center }
+
+div.admonition, 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.admonition p.admonition-title, 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.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 }
+
+/* Uncomment (and remove this text!) to get reduced vertical space in
+   compound paragraphs.
+div.compound .compound-first, div.compound .compound-middle {
+  margin-bottom: 0.5em }
+
+div.compound .compound-last, div.compound .compound-middle {
+  margin-top: 0.5em }
+*/
+
+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 ;
+  margin-right: 2em }
+
+div.footer, div.header {
+  clear: both;
+  font-size: smaller }
+
+div.line-block {
+  display: block ;
+  margin-top: 1em ;
+  margin-bottom: 1em }
+
+div.line-block div.line-block {
+  margin-top: 0 ;
+  margin-bottom: 0 ;
+  margin-left: 1.5em }
+
+div.sidebar {
+  margin-left: 1em ;
+  border: medium outset ;
+  padding: 1em ;
+  background-color: #ffffee ;
+  width: 40% ;
+  float: right ;
+  clear: right }
+
+div.sidebar p.rubric {
+  font-family: sans-serif ;
+  font-size: medium }
+
+div.system-messages {
+  margin: 5em }
+
+div.system-messages h1 {
+  color: red }
+
+div.system-message {
+  border: medium outset ;
+  padding: 1em }
+
+div.system-message p.system-message-title {
+  color: red ;
+  font-weight: bold }
+
+div.topic {
+  margin: 2em }
+
+h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
+h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
+  margin-top: 0.4em }
+
+h1.title {
+  text-align: center }
+
+h2.subtitle {
+  text-align: center }
+
+hr.docutils {
+  width: 75% }
+
+img.align-left {
+  clear: left }
+
+img.align-right {
+  clear: right }
+
+ol.simple, ul.simple {
+  margin-bottom: 1em }
+
+ol.arabic {
+  list-style: decimal }
+
+ol.loweralpha {
+  list-style: lower-alpha }
+
+ol.upperalpha {
+  list-style: upper-alpha }
+
+ol.lowerroman {
+  list-style: lower-roman }
+
+ol.upperroman {
+  list-style: upper-roman }
+
+p.attribution {
+  text-align: right ;
+  margin-left: 50% }
+
+p.caption {
+  font-style: italic }
+
+p.credits {
+  font-style: italic ;
+  font-size: smaller }
+
+p.label {
+  white-space: nowrap }
+
+p.rubric {
+  font-weight: bold ;
+  font-size: larger ;
+  color: maroon ;
+  text-align: center }
+
+p.sidebar-title {
+  font-family: sans-serif ;
+  font-weight: bold ;
+  font-size: larger }
+
+p.sidebar-subtitle {
+  font-family: sans-serif ;
+  font-weight: bold }
+
+p.topic-title {
+  font-weight: bold }
+
+pre.address {
+  margin-bottom: 0 ;
+  margin-top: 0 ;
+  font-family: serif ;
+  font-size: 100% }
+
+pre.literal-block, pre.doctest-block {
+  margin-left: 2em ;
+  margin-right: 2em ;
+  background-color: #eeeeee }
+
+span.classifier {
+  font-family: sans-serif ;
+  font-style: oblique }
+
+span.classifier-delimiter {
+  font-family: sans-serif ;
+  font-weight: bold }
+
+span.interpreted {
+  font-family: sans-serif }
+
+span.option {
+  white-space: nowrap }
+
+span.pre {
+  white-space: pre }
+
+span.problematic {
+  color: red }
+
+span.section-subtitle {
+  /* font-size relative to parent (h1..h6 element) */
+  font-size: 80% }
+
+table.citation {
+  border-left: solid 1px gray;
+  margin-left: 1px }
+
+table.docinfo {
+  margin: 2em 4em }
+
+table.docutils {
+  margin-top: 0.5em ;
+  margin-bottom: 0.5em }
+
+table.footnote {
+  border-left: solid 1px black;
+  margin-left: 1px }
+
+table.docutils td, table.docutils th,
+table.docinfo td, table.docinfo th {
+  padding-left: 0.5em ;
+  padding-right: 0.5em ;
+  vertical-align: top }
+
+table.docutils th.field-name, table.docinfo th.docinfo-name {
+  font-weight: bold ;
+  text-align: left ;
+  white-space: nowrap ;
+  padding-left: 0 }
+
+h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
+h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
+  font-size: 100% }
+
+tt.docutils {
+  background-color: #eeeeee }
+
+ul.auto-toc {
+  list-style-type: none }
+
+</style>
+</head>
+<body>
+<div class="document" id="problem-with-is-writable-and-is-swappable-in-n1550">
+<h1 class="title">Problem with <tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils 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="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 and 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 Bloomington</td></tr>
+<tr><th class="docinfo-name">Date:</th>
+<td>2003-11-19</td></tr>
+<tr><th class="docinfo-name">Copyright:</th>
+<td>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">
+<p class="topic-title first"><a id="table-of-contents" 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">
+<h1><a class="toc-backref" href="#id1" id="introduction" name="introduction">Introduction</a></h1>
+<p>The <tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils 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="docutils literal"><span class="pre">iterator_traits&lt;X&gt;::iterator_category</span></tt>
+for the old iterator concepts. For backward compatibility,
+<tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils 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="docutils literal"><span class="pre">iterator_category</span></tt> and also the <tt class="docutils 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="docutils 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="docutils literal"><span class="pre">value_type</span></tt> of the iterator <tt class="docutils 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="docutils literal"><span class="pre">reference</span></tt> type of the iterator is <tt class="docutils literal"><span class="pre">B&amp;</span></tt>.  In
+that case, <tt class="docutils literal"><span class="pre">is_writable&lt;It&gt;::value</span></tt> will be true when in fact
+attempting to write into <tt class="docutils literal"><span class="pre">B</span></tt> will cause an error.</p>
+<p>The same problem applies to <tt class="docutils literal"><span class="pre">is_swappable</span></tt>.</p>
+</div>
+<div class="section">
+<h1><a class="toc-backref" href="#id2" id="proposed-resolution" name="proposed-resolution">Proposed Resolution</a></h1>
+<ol class="arabic">
+<li><p class="first">Remove the <tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils 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="docutils literal"><span class="pre">is_readable</span></tt> specification to be:
+<tt class="docutils literal"><span class="pre">is_readable&lt;X&gt;::type</span></tt> is <tt class="docutils literal"><span class="pre">true_type</span></tt> if the
+result type of <tt class="docutils literal"><span class="pre">X::operator*</span></tt> is convertible to
+<tt class="docutils literal"><span class="pre">iterator_traits&lt;X&gt;::value_type</span></tt> and is <tt class="docutils literal"><span class="pre">false_type</span></tt>
+otherwise. Also, <tt class="docutils 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="docutils literal"><span class="pre">is_readable</span></tt> trait from
+the Readable Iterator concept.</p>
+</li>
+<li><p class="first">Remove the <tt class="docutils literal"><span class="pre">iterator_tag</span></tt> class.</p>
+</li>
+<li><p class="first">Change the specification of <tt class="docutils 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">
+<h1><a class="toc-backref" href="#id3" id="rationale" name="rationale">Rationale</a></h1>
+<ol class="arabic simple">
+<li>There are two reasons for removing <tt class="docutils literal"><span class="pre">is_writable</span></tt>
+and <tt class="docutils 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="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils 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="docutils literal"><span class="pre">is_readable</span></tt> trait can be implemented
+using only the iterator type itself and its <tt class="docutils literal"><span class="pre">value_type</span></tt>.
+Therefore we remove the requirement for <tt class="docutils literal"><span class="pre">is_readable</span></tt> from the
+Readable Iterator concept, and change the definition of
+<tt class="docutils literal"><span class="pre">is_readable</span></tt> so that it works for any iterator type.</li>
+<li>The purpose of the <tt class="docutils literal"><span class="pre">iterator_tag</span></tt> class was to
+bundle the traversal and access category tags
+into the <tt class="docutils literal"><span class="pre">iterator_category</span></tt> typedef.
+With <tt class="docutils literal"><span class="pre">is_writable</span></tt> and <tt class="docutils literal"><span class="pre">is_swappable</span></tt> gone, and
+<tt class="docutils 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="docutils literal"><span class="pre">iterator_tag</span></tt>. The
+traversal tag can be directly used for the
+<tt class="docutils 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="docutils literal"><span class="pre">iterator_category</span></tt>.</li>
+<li>The changes to the specification of <tt class="docutils literal"><span class="pre">traversal_category</span></tt> are a
+direct result of the removal of <tt class="docutils literal"><span class="pre">iterator_tag</span></tt>.</li>
+</ol>
+</div>
+</div>
+</body>
+</html>

doc/iterator_facade.html

@@ -866,7 +866,7 @@ operator -(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
 <p>In this section we'll walk through the implementation of a few
 iterators using <tt class="docutils literal"><span class="pre">iterator_facade</span></tt>, based around the simple
 example of a linked list of polymorphic objects.  This example was
-inspired by a <a class="reference external" href="http://thread.gmane.org/gmane.comp.lib.boost.user/5100">posting</a> by Keith Macdonald on the <a class="reference external" href="../../../more/mailing_lists.htm#users">Boost-Users</a>
+inspired by a <a class="reference external" href="http://thread.gmane.org/gmane.comp.lib.boost.user/5100">posting</a> by Keith Macdonald on the <a class="reference external" href="http://www.boost.org/more/mailing_lists.htm#users">Boost-Users</a>
 mailing list.</p>
 <div class="section" id="the-problem">
 <h2><a class="toc-backref" href="#id32">The Problem</a></h2>

doc/iterator_facade_tutorial.rst

@@ -8,7 +8,7 @@ example of a linked list of polymorphic objects.  This example was
 inspired by a `posting`__ by Keith Macdonald on the `Boost-Users`_
 mailing list.
 
-.. _`Boost-Users`: ../../../more/mailing_lists.htm#users
+.. _`Boost-Users`: http://www.boost.org/more/mailing_lists.htm#users
 
 __ http://thread.gmane.org/gmane.comp.lib.boost.user/5100
 

doc/quickbook/facade_tutorial.qbk

@@ -7,7 +7,7 @@ example of a linked list of polymorphic objects.  This example was
 inspired by a 
 [@http://thread.gmane.org/gmane.comp.lib.boost.user/5100 `posting`]
 by Keith Macdonald on the 
-[@../../../more/mailing_lists.htm#users `Boost-Users`]
+[@http://www.boost.org/more/mailing_lists.htm#users `Boost-Users`]
 mailing list.
 
 

doc/quickbook/iterator.qbk

@@ -32,7 +32,7 @@
 
 [section:intro Introduction]
 
-[def _concepts_ [@../../more/generic_programming.html#concept concepts]]
+[def _concepts_ [@http://www.boost.org/more/generic_programming.html#concept concepts]]
 
 The Boost Iterator Library contains two parts. The first
 is a system of _concepts_ which extend the C++ standard
@@ -203,7 +203,7 @@ templates.
 
 [section:upgrading Upgrading from the old Boost Iterator Adaptor Library]
 
-[def _type_generator_ [@../../more/generic_programming.html#type_generator type generator]]
+[def _type_generator_ [@http://www.boost.org/more/generic_programming.html#type_generator type generator]]
 
 If you have been using the old Boost Iterator Adaptor library to
 implement iterators, you probably wrote a `Policies` class which

example/Jamfile

@@ -0,0 +1,17 @@
+# Copyright David Abrahams 2006. Distributed under the Boost
+# Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+test-suite iterator_examples
+  : [ run reverse_iterator.cpp ]
+    [ run node_iterator1.cpp ]
+    [ run node_iterator2.cpp ]
+    [ run node_iterator3.cpp ]
+    [ run counting_iterator_example.cpp ]
+    [ run filter_iterator_example.cpp ]
+    [ run func_output_iter_example.cpp ]
+    [ run indirect_iterator_example.cpp ]
+    [ run permutation_iter_example.cpp ]
+    [ run reverse_iterator_example.cpp ]
+    [ run transform_iterator_example.cpp ]
+      ;

include/boost/iterator/detail/config_def.hpp

@@ -47,9 +47,11 @@
 #endif
 
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                                       \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531))                   \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0))                   \
     || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
-    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
+    || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))                \
+    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+    
 # define BOOST_NO_LVALUE_RETURN_DETECTION
 
 # if 0 // test code

include/boost/iterator/indirect_iterator.hpp

@@ -110,7 +110,7 @@ namespace boost
   private:    
       typename super_t::reference dereference() const
       {
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+# if BOOST_WORKAROUND(__BORLANDC__, < 0x5A0 )
           return const_cast<super_t::reference>(**this->base());
 # else
           return **this->base();

include/boost/iterator/iterator_adaptor.hpp

@@ -24,9 +24,14 @@
 
 #ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
 # include <boost/type_traits/remove_reference.hpp>
-#else 
+
+# if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
+#   include <boost/type_traits/add_reference.hpp>
+# endif
+
+#else
 # include <boost/type_traits/add_reference.hpp>
-#endif 
+#endif
 
 #include <boost/iterator/detail/config_def.hpp>
 

include/boost/iterator/iterator_facade.hpp

@@ -433,26 +433,26 @@ namespace boost
 # ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
 #  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)       \
     template <                                                              \
-        class Derived1, class V1, class TC1, class R1, class D1             \
-      , class Derived2, class V2, class TC2, class R2, class D2             \
+        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
+      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
     >                                                                       \
     prefix typename mpl::apply2<result_type,Derived1,Derived2>::type \
     operator op(                                                            \
-        iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs               \
-      , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)
+        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
+      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
 # else 
 #  define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type)   \
     template <                                                          \
-        class Derived1, class V1, class TC1, class R1, class D1         \
-      , class Derived2, class V2, class TC2, class R2, class D2         \
+        class Derived1, class V1, class TC1, class Reference1, class Difference1 \
+      , class Derived2, class V2, class TC2, class Reference2, class Difference2 \
     >                                                                   \
     prefix typename boost::detail::enable_if_interoperable<             \
         Derived1, Derived2                                              \
       , typename mpl::apply2<result_type,Derived1,Derived2>::type       \
     >::type                                                             \
     operator op(                                                        \
-        iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs           \
-      , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)
+        iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs   \
+      , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
 # endif 
 
 #  define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args)              \
@@ -470,8 +470,7 @@ namespace boost
   //
   class iterator_core_access
   {
-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)                  
       // Tasteless as this may seem, making all members public allows member templates
       // to work in the absence of member template friends.
    public:

include/boost/iterator_adaptors.hpp

@@ -1,6 +1,9 @@
 // Copyright David Abrahams 2004. Distributed under the Boost
 // Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See www.boost.org/libs/iterator for documentation.
+
 #ifndef ITERATOR_ADAPTORS_DWA2004725_HPP
 # define ITERATOR_ADAPTORS_DWA2004725_HPP