From f0e47acb8ed17086c2992471a0e365fa667b7435 Mon Sep 17 00:00:00 2001
From: Jeremy Siek <jeremy.siek@gmail.com>
Date: Fri, 18 May 2001 22:44:29 +0000
Subject: [PATCH] fixed a few things, added non-mutable versions

[SVN r10138]
---
 include/boost/concept_archetype.hpp | 95 +++++++++++++++++++++++++++--
 1 file changed, 89 insertions(+), 6 deletions(-)

diff --git a/include/boost/concept_archetype.hpp b/include/boost/concept_archetype.hpp
index d03ebd4..14b3b64 100644
--- a/include/boost/concept_archetype.hpp
+++ b/include/boost/concept_archetype.hpp
@@ -526,7 +526,7 @@ namespace boost {
   public:
     typedef std::forward_iterator_tag iterator_category;
     typedef T value_type;
-    typedef T& reference;
+    typedef const T& reference;
     typedef T* pointer;
     typedef std::ptrdiff_t difference_type;
     forward_iterator_archetype() { }
@@ -538,6 +538,26 @@ namespace boost {
     self operator++(int) { return *this; }
   };
 
+  template <class T>
+  class mutable_forward_iterator_archetype
+  {
+  public:
+    typedef mutable_forward_iterator_archetype self;
+  public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef T value_type;
+    typedef T& reference;
+    typedef T* pointer;
+    typedef std::ptrdiff_t difference_type;
+    mutable_forward_iterator_archetype() { }
+    self& operator=(const self&) { return *this;  }
+    bool operator==(const self&) const { return true; }
+    bool operator!=(const self&) const { return true; }
+    reference operator*() const { return static_object<T>::get(); }
+    self& operator++() { return *this; }
+    self operator++(int) { return *this; }
+  };
+
   template <class T>
   class bidirectional_iterator_archetype
   {
@@ -546,7 +566,7 @@ namespace boost {
   public:
     typedef std::bidirectional_iterator_tag iterator_category;
     typedef T value_type;
-    typedef T& reference;
+    typedef const T& reference;
     typedef T* pointer;
     typedef std::ptrdiff_t difference_type;
     bidirectional_iterator_archetype() { }
@@ -560,6 +580,28 @@ namespace boost {
     self operator--(int) { return *this; }
   };
 
+  template <class T>
+  class mutable_bidirectional_iterator_archetype
+  {
+  public:
+    typedef mutable_bidirectional_iterator_archetype self;
+  public:
+    typedef std::bidirectional_iterator_tag iterator_category;
+    typedef T value_type;
+    typedef T& reference;
+    typedef T* pointer;
+    typedef std::ptrdiff_t difference_type;
+    mutable_bidirectional_iterator_archetype() { }
+    self& operator=(const self&) { return *this;  }
+    bool operator==(const self&) const { return true; }
+    bool operator!=(const self&) const { return true; }
+    reference operator*() const { return static_object<T>::get(); }
+    self& operator++() { return *this; }
+    self operator++(int) { return *this; }
+    self& operator--() { return *this; }
+    self operator--(int) { return *this; }
+  };
+
   template <class T>
   class random_access_iterator_archetype
   {
@@ -568,7 +610,7 @@ namespace boost {
   public:
     typedef std::random_access_iterator_tag iterator_category;
     typedef T value_type;
-    typedef T& reference;
+    typedef const T& reference;
     typedef T* pointer;
     typedef std::ptrdiff_t difference_type;
     random_access_iterator_archetype() { }
@@ -580,14 +622,14 @@ namespace boost {
     self operator++(int) { return *this; }
     self& operator--() { return *this; }
     self operator--(int) { return *this; }
-    reference operator[](difference_type) 
+    reference operator[](difference_type) const
       { return static_object<T>::get(); }
     self& operator+=(difference_type) { return *this; }
     self& operator-=(difference_type) { return *this; }
     difference_type operator-(const self&) const
       { return difference_type(); }
-    self operator+(difference_type) { return *this; }
-    self operator-(difference_type) { return *this; }
+    self operator+(difference_type) const { return *this; }
+    self operator-(difference_type) const { return *this; }
     bool operator<(const self&) { return true; }
     bool operator<=(const self&) { return true; }
     bool operator>(const self&) { return true; }
@@ -599,6 +641,47 @@ namespace boost {
             const random_access_iterator_archetype<T>& x) 
     { return x; }
 
+
+  template <class T>
+  class mutable_random_access_iterator_archetype
+  {
+  public:
+    typedef mutable_random_access_iterator_archetype self;
+  public:
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef T value_type;
+    typedef T& reference;
+    typedef T* pointer;
+    typedef std::ptrdiff_t difference_type;
+    mutable_random_access_iterator_archetype() { }
+    self& operator=(const self&) { return *this;  }
+    bool operator==(const self&) const { return true; }
+    bool operator!=(const self&) const { return true; }
+    reference operator*() const { return static_object<T>::get(); }
+    self& operator++() { return *this; }
+    self operator++(int) { return *this; }
+    self& operator--() { return *this; }
+    self operator--(int) { return *this; }
+    reference operator[](difference_type) const
+      { return static_object<T>::get(); }
+    self& operator+=(difference_type) { return *this; }
+    self& operator-=(difference_type) { return *this; }
+    difference_type operator-(const self&) const
+      { return difference_type(); }
+    self operator+(difference_type) const { return *this; }
+    self operator-(difference_type) const { return *this; }
+    bool operator<(const self&) { return true; }
+    bool operator<=(const self&) { return true; }
+    bool operator>(const self&) { return true; }
+    bool operator>=(const self&) { return true; }
+  };
+  template <class T>
+  mutable_random_access_iterator_archetype<T> 
+  operator+
+    (typename mutable_random_access_iterator_archetype<T>::difference_type, 
+     const mutable_random_access_iterator_archetype<T>& x) 
+    { return x; }
+
 } // namespace boost
 
 #endif // BOOST_CONCEPT_ARCHETYPES_H