[Boost-commit] svn:boost r45937 - sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs

From: asutton_at_[hidden]
Date: 2008-05-30 08:06:03

Author: asutton
Date: 2008-05-30 08:06:02 EDT (Fri, 30 May 2008)
New Revision: 45937
URL: http://svn.boost.org/trac/boost/changeset/45937

Log:
Fixed all of the iterators to actually work as iterators.

Text files modified: 
   sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/indexed_vertex_iterator.hpp |   188 ++++++++++++++++++++++++++------------- 
   sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/mapped_vertex_iterator.hpp  |    98 +++++++++++++++-----                    
   sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/value_vertex_iterator.hpp   |   110 +++++++++++++++-------                  
   3 files changed, 272 insertions(+), 124 deletions(-)

Modified: sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/indexed_vertex_iterator.hpp
==============================================================================
--- sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/indexed_vertex_iterator.hpp	(original)
+++ sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/indexed_vertex_iterator.hpp	2008-05-30 08:06:02 EDT (Fri, 30 May 2008)
@@ -10,7 +10,9 @@
 
 /**
  * The indexed vertex iterator provides a vertex iterator for stores whose
- * descriptors cannot be pointers (i.e., vectors).
+ * descriptors cannot be pointers (i.e., vectors). By virtue of the fact that
+ * Store is required to be a vector of something, this is a random access
+ * iterator.
  */
 template <typename Store>
 class indexed_vertex_iterator
@@ -26,76 +28,134 @@
     typedef vertex_descriptor reference;
     typedef vertex_descriptor pointer;
 
-    inline indexed_vertex_iterator()
-        : store(0)
-        , iter()
-    { }
-
-    inline indexed_vertex_iterator(indexed_vertex_iterator const& x)
-        : store(x.store)
-        , iter(x.iter)
-    { }
-
-    inline indexed_vertex_iterator(Store const& s, iterator const& x)
-        : store(&s)
-        , iter(x)
-    { }
-
-    inline indexed_vertex_iterator& operator++()
-    {
-        ++iter;
-        return *this;
-    }
-
-    inline indexed_vertex_iterator& operator=(indexed_vertex_iterator const& x)
-    {
-        indexed_vertex_iterator t(x);
-        swap(t);
-        return *this;
-    }
-
-    inline indexed_vertex_iterator& operator+=(difference_type n)
-    {
-        iter += n;
-        return *this;
-    }
-
-    inline indexed_vertex_iterator& operator-=(difference_type n)
-    {
-        iter -= n;
-        return *this;
-    }
-
-    // Support addition and subtraction as per random access iterators
-    inline indexed_vertex_iterator operator+(difference_type n) const
-    { return iter + n; }
+    // Constructors
+    inline indexed_vertex_iterator();
+    inline indexed_vertex_iterator(indexed_vertex_iterator const& x);
+    inline indexed_vertex_iterator(Store const& s, iterator const& x);
+
+    // Assignment and increment
+    inline indexed_vertex_iterator& operator=(indexed_vertex_iterator const& x);
+    inline indexed_vertex_iterator& operator+=(difference_type n);
+    inline indexed_vertex_iterator& operator-=(difference_type n);
+    inline indexed_vertex_iterator& operator++();
+    inline indexed_vertex_iterator& operator--();
+
+    inline indexed_vertex_iterator operator+(difference_type n) const;
+    inline indexed_vertex_iterator operator-(difference_type n) const;
+    inline difference_type operator-(indexed_vertex_iterator const& x) const;
 
-    inline indexed_vertex_iterator operator-(difference_type n) const
-    { return iter - n; }
+    inline reference operator*();
 
-    inline difference_type operator-(indexed_vertex_iterator const& x) const
-    { return iter - x.iter; }
+    inline bool operator==(indexed_vertex_iterator const& x) const;
+    inline bool operator!=(indexed_vertex_iterator const& x) const;
 
-    // The returned descriptor is simply the distance from the beginning of
-    // the underlying store to the end.
-    inline reference operator*()
-    { return std::distance(store->begin(), iter); }
+private:
+    Store const* store;
+    iterator iter;
+};
 
-    inline bool operator==(indexed_vertex_iterator const& x) const
-    { return (store == x.store) && (iter == x.iter); }
+template <typename S>
+indexed_vertex_iterator<S>::indexed_vertex_iterator()
+    : store(0)
+    , iter()
+{ }
+
+template <typename S>
+indexed_vertex_iterator<S>::indexed_vertex_iterator(indexed_vertex_iterator const& x)
+    : store(x.store)
+    , iter(x.iter)
+{ }
+
+template <typename S>
+indexed_vertex_iterator<S>::indexed_vertex_iterator(S const& s, iterator const& x)
+    : store(&s)
+    , iter(x)
+{ }
+
+template <typename S>
+indexed_vertex_iterator<S>&
+indexed_vertex_iterator<S>::operator=(indexed_vertex_iterator const& x)
+{
+    iter = x.iter;
+    store = x.store;
+    return *this;
+}
+
+template <typename S>
+indexed_vertex_iterator<S>&
+indexed_vertex_iterator<S>::operator+=(difference_type n)
+{
+    iter += n;
+    return *this;
+}
+
+template <typename S>
+indexed_vertex_iterator<S>&
+indexed_vertex_iterator<S>::operator-=(difference_type n)
+{
+    iter -= n;
+    return *this;
+}
+
+template <typename S>
+indexed_vertex_iterator<S>&
+indexed_vertex_iterator<S>::operator++()
+{
+    ++iter;
+    return *this;
+}
+
+template <typename S>
+indexed_vertex_iterator<S>&
+indexed_vertex_iterator<S>::operator--()
+{
+    --iter;
+    return *this;
+}
+
+template <typename S>
+indexed_vertex_iterator<S>
+indexed_vertex_iterator<S>::operator+(difference_type n) const
+{
+    return iter + n;
+}
 
-    inline bool operator!=(indexed_vertex_iterator const& x) const
-    { return (store == x.store) && (iter != x.iter); }
+template <typename S>
+indexed_vertex_iterator<S>
+indexed_vertex_iterator<S>::operator-(difference_type n) const
+{
+    return iter - n;
+}
 
-    inline void swap(indexed_vertex_iterator& x)
-    {
-        std::swap(store, x.store);
-        std::swap(iter, x.iter);
-    }
+template <typename S>
+typename indexed_vertex_iterator<S>::difference_type
+indexed_vertex_iterator<S>::operator-(indexed_vertex_iterator const& x) const
+{
+    return iter - x.iter;
+}
 
-    Store const* store;
-    iterator iter;
-};
+template <typename S>
+typename indexed_vertex_iterator<S>::reference
+indexed_vertex_iterator<S>::operator*()
+{
+    // The returned descriptor is simply the distance from the beginning of
+    // the underlying store to the end.
+    return std::distance(store->begin(), iter);
+}
+
+template <typename S>
+bool
+indexed_vertex_iterator<S>::operator==(indexed_vertex_iterator const& x) const
+{
+     return (store == x.store) && (iter == x.iter);
+}
+
+template <typename S>
+bool
+indexed_vertex_iterator<S>::operator!=(indexed_vertex_iterator const& x) const
+{
+    return (store == x.store) && (iter != x.iter);
+}
 
 } /* namespace adj_list */
 } /* namespace graphs */

Modified: sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/mapped_vertex_iterator.hpp
==============================================================================
--- sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/mapped_vertex_iterator.hpp	(original)
+++ sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/mapped_vertex_iterator.hpp	2008-05-30 08:06:02 EDT (Fri, 30 May 2008)
@@ -9,7 +9,8 @@
 /**
  * The mapped vertex iterator provides a vertex iterator pair associative
  * storage containers. This essintially wraps a store iterator, providing
- * the ability to dererence to descriptors.
+ * the ability to dererence to descriptors. Because this iterator is taken
+ * from pair associative structures, it is bidirectional but not random access.
  */
 template <typename Store>
 class mapped_vertex_iterator
@@ -19,40 +20,89 @@
     typedef typename Store::mapped_type vertex_type;
     typedef typename vertex_type::descriptor_type vertex_descriptor;
 
+    typedef typename iterator::iterator_category iterator_category;
+    typedef typename iterator::difference_type difference_type;
     typedef vertex_descriptor value_type;
     typedef vertex_descriptor reference;
     typedef vertex_descriptor pointer;
 
-    inline mapped_vertex_iterator()
-        : iter()
-    { }
-
-    inline mapped_vertex_iterator(mapped_vertex_iterator const& x)
-        : iter(x.iter)
-    { }
-
-    inline mapped_vertex_iterator(iterator const& x)
-        : iter(x)
-    { }
-
-    inline mapped_vertex_iterator& operator++()
-    {
-        ++iter;
-        return *this;
-    }
+    inline mapped_vertex_iterator();
+    inline mapped_vertex_iterator(mapped_vertex_iterator const& x);
+    inline mapped_vertex_iterator(iterator const& x);
 
-    inline reference operator*()
-    { return &const_cast<vertex_type&>(iter->second); }
+    inline mapped_vertex_iterator& operator=(mapped_vertex_iterator const& x);
+    inline mapped_vertex_iterator& operator++();
+    inline mapped_vertex_iterator& operator--();
 
-    inline bool operator==(mapped_vertex_iterator const& x) const
-    { return iter == x.iter; }
+    inline reference operator*();
 
-    inline bool operator!=(mapped_vertex_iterator const& x) const
-    { return iter != x.iter; }
+    inline bool operator==(mapped_vertex_iterator const& x) const;
+    inline bool operator!=(mapped_vertex_iterator const& x) const;
 
+private:
     iterator iter;
 };
 
+template <typename S>
+mapped_vertex_iterator<S>::mapped_vertex_iterator()
+    : iter()
+{ }
+
+template <typename S>
+mapped_vertex_iterator<S>::mapped_vertex_iterator(mapped_vertex_iterator const& x)
+    : iter(x.iter)
+{ }
+
+template <typename S>
+mapped_vertex_iterator<S>::mapped_vertex_iterator(iterator const& x)
+    : iter(x)
+{ }
+
+template <typename S>
+mapped_vertex_iterator<S>&
+mapped_vertex_iterator<S>::operator=(mapped_vertex_iterator const& x)
+{
+    iter = x.iter;
+    return *this;
+}
+
+template <typename S>
+mapped_vertex_iterator<S>&
+mapped_vertex_iterator<S>::operator++()
+{
+    ++iter;
+    return *this;
+}
+
+template <typename S>
+mapped_vertex_iterator<S>&
+mapped_vertex_iterator<S>::operator--()
+{
+    --iter;
+    return *this;
+}
+
+template <typename S>
+typename mapped_vertex_iterator<S>::reference
+mapped_vertex_iterator<S>::operator*()
+{
+    return &const_cast<vertex_type&>(iter->second);
+}
+
+template <typename S>
+bool
+mapped_vertex_iterator<S>::operator==(mapped_vertex_iterator const& x) const
+{
+    return iter == x.iter;
+}
+
+template <typename S>
+bool
+mapped_vertex_iterator<S>::operator!=(mapped_vertex_iterator const& x) const
+{
+    return iter != x.iter;
+}
+
 } /* namespace adj_list */
 } /* namespace graph */
 } /* namespace boost */

Modified: sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/value_vertex_iterator.hpp
==============================================================================
--- sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/value_vertex_iterator.hpp	(original)
+++ sandbox/SOC/2008/graphs/boost/graphs/adjacency_list/vs/value_vertex_iterator.hpp	2008-05-30 08:06:02 EDT (Fri, 30 May 2008)
@@ -1,6 +1,6 @@
 
-#ifndef BOOST_GRAPHS_ADJACENCY_LIST_VALUE_VERTEX_ITERATOR_HPP
-#define BOOST_GRAPHS_ADJACENCY_LIST_VALUE_VERTEX_ITERATOR_HPP
+#ifndef BOOST_GRAPHS_ADJACENCY_LIST_SIMPLE_VERTEX_ITERATOR_HPP
+#define BOOST_GRAPHS_ADJACENCY_LIST_SIMPLE_VERTEX_ITERATOR_HPP
 
 #include <iterator>
 
@@ -12,12 +12,9 @@
  * The value vertex iterator provides a vertex iterator unique associative
  * containers and sequences that don't invalidate memory on insertions
  * (lists).
- *
- * Note that this is actually a random access iterator and can be used to
- * support trivial fill (memset) and copy (memcpy) operations.
  */
 template <typename Store>
-class value_vertex_iterator
+class simple_vertex_iterator
 {
     typedef typename Store::const_iterator iterator;
 public:
@@ -25,47 +22,88 @@
     typedef typename vertex_type::descriptor_type vertex_descriptor;
 
     typedef typename iterator::iterator_category iterator_category;
+    typedef typename iterator::difference_type difference_type;
     typedef vertex_descriptor value_type;
     typedef vertex_descriptor reference;
     typedef vertex_descriptor pointer;
-    typedef typename iterator::difference_type difference_type;
 
-    inline value_vertex_iterator()
-        : iter()
-    { }
-
-    inline value_vertex_iterator(value_vertex_iterator const& x)
-        : iter(x.iter)
-    { }
-
-    inline value_vertex_iterator(iterator const& x)
-        : iter(x)
-    { }
-
-    inline value_vertex_iterator& operator++()
-    {
-        ++iter;
-        return *this;
-    }
-
-    inline value_vertex_iterator& operator--()
-    {
-        --iter;
-        return *this;
-    }
+    inline simple_vertex_iterator();
+    inline simple_vertex_iterator(simple_vertex_iterator const& x);
+    inline simple_vertex_iterator(iterator const& x);
 
-    inline reference operator*()
-    { return &const_cast<vertex_type&>(*iter); }
+    inline simple_vertex_iterator& operator=(simple_vertex_iterator const& x);
+    inline simple_vertex_iterator& operator++();
+    inline simple_vertex_iterator& operator--();
 
-    inline bool operator==(value_vertex_iterator const& x) const
-    { return iter == x.iter; }
+    inline reference operator*();
 
-    inline bool operator!=(value_vertex_iterator const& x) const
-    { return iter != x.iter; }
+    inline bool operator==(simple_vertex_iterator const& x) const;
+    inline bool operator!=(simple_vertex_iterator const& x) const;
 
+private:
     iterator iter;
 };
 
+template <typename S>
+simple_vertex_iterator<S>::simple_vertex_iterator()
+    : iter()
+{ }
+
+template <typename S>
+simple_vertex_iterator<S>::simple_vertex_iterator(simple_vertex_iterator const& x)
+    : iter(x.iter)
+{ }
+
+template <typename S>
+simple_vertex_iterator<S>::simple_vertex_iterator(iterator const& x)
+    : iter(x)
+{ }
+
+template <typename S>
+simple_vertex_iterator<S>&
+simple_vertex_iterator<S>::operator=(simple_vertex_iterator const& x)
+{
+    iter = x.iter;
+    return *this;
+}
+
+template <typename S>
+simple_vertex_iterator<S>&
+simple_vertex_iterator<S>::operator++()
+{
+    ++iter;
+    return *this;
+}
+
+template <typename S>
+simple_vertex_iterator<S>&
+simple_vertex_iterator<S>::operator--()
+{
+    --iter;
+    return *this;
+}
+
+template <typename S>
+typename simple_vertex_iterator<S>::reference
+simple_vertex_iterator<S>::operator*()
+{
+    return &const_cast<vertex_type&>(*iter);
+}
+
+template <typename S>
+bool
+simple_vertex_iterator<S>::operator==(simple_vertex_iterator const& x) const
+{
+    return iter == x.iter;
+}
+
+template <typename S>
+bool
+simple_vertex_iterator<S>::operator!=(simple_vertex_iterator const& x) const
+{
+    return iter != x.iter;
+}
+
 } /* namespace adj_list */
 } /* namespace graphs */
 } /* namespace boost */