moved into this branch from developement directory

[SVN r10461]

concept_tests.cpp

@@ -0,0 +1,73 @@
+#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/boost/iterator_categories.hpp

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

@@ -2,7 +2,9 @@
 #define BOOST_ITERATOR_CONCEPTS_HPP
 
 #include <boost/concept_check.hpp>
-#include <boost/iterator_traits.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
@@ -11,23 +13,24 @@ namespace boost_concepts {
 
 
   //===========================================================================
+  // Iterator Access Concepts
 
   template <typename Iterator>
   class ReadableIteratorConcept {
   public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::return_category 
-      return_category;
+    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::function_requires< 
-        boost::ConvertibleConcept<return_category, boost::readable_iterator_tag> >();
-
+        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);
@@ -38,18 +41,18 @@ namespace boost_concepts {
   template <typename Iterator, typename ValueType>
   class WritableIteratorConcept {
   public:
-    typedef typename boost::iterator_traits<Iterator>::return_category 
-      return_category;
+    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::function_requires< 
-        boost::ConvertibleConcept<return_category, boost::writable_iterator_tag> >();
+        boost::DefaultConstructibleConcept<Iterator> >();
+      
+      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*,
+                           boost::writable_iterator_tag*>::value));
 
-      *i = v; // an alternative could be something like write(x, v)
+      *i = v; // a good alternative could be something like write(x, v)
     }
     ValueType v;
     Iterator i;
@@ -58,19 +61,18 @@ namespace boost_concepts {
   template <typename Iterator>
   class ConstantLvalueIteratorConcept {
   public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::return_category 
-      return_category;
+    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< 
-        boost::ConvertibleConcept<return_category, 
-          boost::constant_lvalue_iterator_tag> >();
 
-      typedef typename boost::require_same<reference, const value_type&>::type req;
+      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);
@@ -81,20 +83,19 @@ namespace boost_concepts {
   template <typename Iterator>
   class MutableLvalueIteratorConcept {
   public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::return_category 
-      return_category;
+    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::function_requires< 
-        boost::ConvertibleConcept<return_category, 
-          boost::constant_lvalue_iterator_tag> >();
+        WritableIteratorConcept<Iterator, value_type> >();
+      
+      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*, 
+                           boost::mutable_lvalue_iterator_tag*>::value));
 
-      typedef typename boost::require_same<reference, value_type&>::type req;
+      BOOST_STATIC_ASSERT((boost::is_same<reference, value_type&>::value));
 
       reference v = *i;
       boost::ignore_unused_variable_warning(v);
@@ -103,60 +104,37 @@ namespace boost_concepts {
   };
   
   //===========================================================================
+  // Iterator Traversal Concepts
 
   template <typename Iterator>
-  class SinglePassIteratorConcept {
+  class ForwardIteratorConcept {
   public:
-    typedef typename boost::iterator_traits<Iterator>::motion_category 
-      motion_category;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
+    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::function_requires< 
-        boost::ConvertibleConcept<motion_category, 
-          boost::single_pass_iterator_tag> >();
-      
-      // difference_type must be a signed integral type
+        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 ForwardIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::motion_category 
-      motion_category;
-
-    void constraints() {
-      boost::function_requires< SinglePassIteratorConcept<Iterator> >();
-
-      boost::function_requires< 
-        boost::ConvertibleConcept<motion_category, 
-          boost::forward_iterator_tag> >();
-    }
-  };
-  
   template <typename Iterator>
   class BidirectionalIteratorConcept {
   public:
-    typedef typename boost::iterator_traits<Iterator>::motion_category 
-      motion_category;
+    typedef typename boost::traversal_category<Iterator>::type traversal_category;
 
     void constraints() {
       boost::function_requires< ForwardIteratorConcept<Iterator> >();
       
-      boost::function_requires< 
-        boost::ConvertibleConcept<motion_category, 
-          boost::bidirectional_iterator_tag> >();
+      BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, 
+                           boost::bidirectional_traversal_tag*>::value));
 
       --i;
       (void)i--;
@@ -167,18 +145,16 @@ namespace boost_concepts {
   template <typename Iterator>
   class RandomAccessIteratorConcept {
   public:
-    typedef typename boost::iterator_traits<Iterator>::motion_category 
-      motion_category;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
+    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::function_requires< 
-        boost::ConvertibleConcept<motion_category, 
-          boost::random_access_iterator_tag> >();
-
+      BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, 
+                           boost::random_access_traversal_tag*>::value));
+      
       i += n;
       i = i + n;
       i = n + i;
@@ -190,92 +166,6 @@ namespace boost_concepts {
     Iterator i, j;
   };
 
-  //===========================================================================
-
-  template <typename Iterator>
-  class ReadableRandomAccessIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-      
-      reference r = i[n];
-      value_type v(r);
-      boost::ignore_unused_variable_warning(v);
-    }
-    difference_type n;
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class WritableRandomAccessIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
-      boost::function_requires< WritableIteratorConcept<Iterator, value_type> >();
-
-      i[n] = v;
-      boost::ignore_unused_variable_warning(v);
-    }
-    difference_type n;
-    value_type v;
-    Iterator i;
-  };
-
-  template <typename Iterator>
-  class ConstantLvalueRandomAccessIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-
-      typedef typename boost::require_same<reference, const value_type&>::type req;
-
-      reference v = i[n];
-      boost::ignore_unused_variable_warning(v);
-    }
-    difference_type n;
-    value_type v;
-    Iterator i;
-  };
-  
-  template <typename Iterator>
-  class MutableLvalueRandomAccessIteratorConcept {
-  public:
-    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
-    typedef typename boost::iterator_traits<Iterator>::reference reference;
-    typedef typename boost::iterator_traits<Iterator>::difference_type
-      difference_type;
-
-    void constraints() {
-      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
-      boost::function_requires< WritableIteratorConcept<Iterator, value_type> >();
-      boost::function_requires< ReadableIteratorConcept<Iterator> >();
-
-      typedef typename boost::require_same<reference, value_type&>::type req;
-
-      reference v = i[n];
-      boost::ignore_unused_variable_warning(v);
-    }
-    difference_type n;
-    value_type v;
-    Iterator i;
-  };
-  
 } // namespace boost_concepts
 
 

development/boost/iterator_traits.hpp

@@ -1,60 +0,0 @@
-#ifndef BOOST_ITERATOR_TRAITS_HPP
-#define BOOST_ITERATOR_TRAITS_HPP
-
-#include <boost/config.hpp>
-#include <boost/type_traits.hpp>
-
-namespace boost {
-  
-  template <typename Iterator>
-  struct iterator_traits {
-    typedef typename Iterator::value_type value_type;
-    typedef typename Iterator::reference reference;
-    typedef typename Iterator::pointer pointer;
-    typedef typename Iterator::difference_type difference_type;
-    typedef typename Iterator::return_category return_category;
-    typedef typename Iterator::motion_category motion_category;
-  };
-
-  // Motion Categories
-  struct single_pass_iterator_tag { };
-  struct forward_iterator_tag : public single_pass_iterator_tag { };
-  struct bidirectional_iterator_tag : public forward_iterator_tag { };
-  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
-  
-  // Return Type Categories
-  struct readable_iterator_tag { };
-  struct writable_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 { };
-  
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-  namespace detail {
-    template <bool IsConst>
-    struct pointer_return_category {
-      typedef constant_lvalue_iterator_tag type;
-    };
-    template <>
-    struct pointer_return_category<false> {
-      typedef mutable_lvalue_iterator_tag type;
-    };
-  } // namespace detail
-
-  template <typename T>
-  struct iterator_traits<T*> {
-    typedef T value_type;
-    typedef T& reference;
-    typedef T* pointer;
-    typedef std::ptrdiff_t difference_type;
-    typedef typename detail::pointer_return_category<is_const<T>::value>::type
-      return_category;
-    typedef random_access_iterator_tag motion_category;
-  };
-
-#endif
-
-} // namespace boost
-
-#endif // BOOST_ITERATOR_TRAITS_HPP

development/libs/iterator/concept_tests.cpp

@@ -1,13 +1,73 @@
 #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()
 {
-  boost::function_requires< 
-    boost_concepts::MutableLvalueRandomAccessIteratorConcept<int*> >();
+#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::ConstantLvalueRandomAccessIteratorConcept<const 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

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

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

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

include/boost/counting_iterator.hpp

@@ -28,6 +28,14 @@
 //     Incrementable.
 // 
 // Revision History
+// 14 Feb 2001  Removed unnecessary typedefs from counting_iterator_traits
+//              (Jeremy Siek)
+// 11 Feb 2001  Use BOOST_STATIC_CONSTANT (Dave Abrahams)
+// 11 Feb 2001  Clean up after John Maddocks's (finally effective!) Borland
+//              fixes (David Abrahams).
+// 10 Feb 2001  Use new iterator_adaptor<> interface (David Abrahams)
+// 10 Feb 2001  Rolled in supposed Borland fixes from John Maddock, but not
+//              seeing any improvement yet (David Abrahams)
 // 09 Feb 2001  Factored out is_numeric computation. Borland still
 //              unhappy :( (David Abrahams)
 // 08 Feb 2001  Beginning of a failed attempt to appease Borland
@@ -126,15 +134,16 @@ namespace detail {
   struct is_numeric {
     // 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);
-    enum { value = 
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-        std::numeric_limits<T>::is_specialized
-#elif defined(__BORLANDC__)
-        ::boost::is_integral<T>::value
-#else
-        boost::is_convertible<int,T>::value && boost::is_convertible<T,int>::value
-#endif
-    };
+# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+    BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
+# 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
   };
 
   // Compute the distance over arbitrary numeric and/or iterator types
@@ -152,14 +161,11 @@ namespace detail {
 template <class Incrementable>
 struct counting_iterator_traits {
  private:
-    enum {numeric = detail::is_numeric<Incrementable>::value };
-    typedef typename detail::counting_iterator_traits_select<(
-        numeric
-        )>::template traits<Incrementable> traits;
+    typedef ::boost::detail::counting_iterator_traits_select<(
+        ::boost::detail::is_numeric<Incrementable>::value
+        )> binder;
+    typedef typename binder::template traits<Incrementable> traits;
  public:
-    typedef Incrementable value_type;
-    typedef const Incrementable& reference;
-    typedef const value_type* pointer;
     typedef typename traits::difference_type difference_type;
     typedef typename traits::iterator_category iterator_category;
 };
@@ -182,9 +188,16 @@ struct counting_iterator_policies : public default_iterator_policies
 template <class Incrementable>
 struct counting_iterator_generator
 {
+    typedef counting_iterator_traits<Incrementable> traits;
+    
     typedef iterator_adaptor<Incrementable,
         counting_iterator_policies<Incrementable>,
-        counting_iterator_traits<Incrementable> > type;
+        Incrementable,
+        const Incrementable&,
+        const Incrementable*,
+        typename traits::iterator_category,
+        typename traits::difference_type
+    > type;
 };
 
 // Manufacture a counting iterator for an arbitrary incrementable type
@@ -192,9 +205,8 @@ template <class Incrementable>
 inline typename counting_iterator_generator<Incrementable>::type
 make_counting_iterator(Incrementable x)
 {
-    return iterator_adaptor<Incrementable,
-        counting_iterator_policies<Incrementable>,
-        counting_iterator_traits<Incrementable> >(x);
+  typedef typename counting_iterator_generator<Incrementable>::type result_t;
+  return result_t(x);
 }
 
 

include/boost/function_output_iterator.hpp

@@ -0,0 +1,55 @@
+// (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

@@ -5,8 +5,10 @@
 // for any purpose.
 //
 // Revision History:
-// 04 Feb 2001  Support for user-defined iterator categories (David Abrahams)
-// 30 Jan 2001  Initial Checkin (David Abrahams)
+// 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_
@@ -75,7 +77,7 @@ namespace detail {
       static const Incrementable choose(const Incrementable& start, const Incrementable& finish)
       {
           return finish_chooser<(
-              boost::is_convertible<Category,std::random_access_iterator_tag>::value
+              ::boost::is_convertible<Category*,std::random_access_iterator_tag*>::value
               )>::template rebind<Incrementable>::choose(start, finish);
       }
   };
@@ -85,16 +87,18 @@ namespace detail {
 template <class Incrementable>
 struct half_open_range
 {
-    typedef iterator_adaptor<Incrementable,
-      counting_iterator_policies<Incrementable>,
-      counting_iterator_traits<Incrementable> > iterator;
+    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 boost::detail::iterator_traits<iterator>::iterator_category category;
+    typedef typename iter_t::iterator_category category;
+    typedef half_open_range<Incrementable> self;
 
  public:
-    typedef iterator const_iterator;
+    typedef iter_t const_iterator;
     typedef typename counting_iterator_traits<Incrementable>::value_type value_type;
     typedef typename counting_iterator_traits<Incrementable>::difference_type difference_type;
     typedef typename counting_iterator_traits<Incrementable>::reference reference;
@@ -130,7 +134,14 @@ struct half_open_range
 #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;

include/boost/iterator_categories.hpp

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

include/boost/iterator_concepts.hpp

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

include/boost/pending/iterator_tests.hpp

@@ -15,12 +15,14 @@
 # include <assert.h>
 # include <boost/type_traits.hpp>
 # include <boost/static_assert.hpp>
+# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
 
 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; }

iterator_categories.htm

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

iterator_concepts.fig

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

iterator_concepts.htm

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