Changeset 1390 for trunk/yat

Timestamp:

Jul 28, 2008, 4:42:13 AM (15 years ago)

Author:

Peter

Message:

fixing #402. Making StrideIterator? inherit from boost::iterator_adaptor solved the problem.

File:

• trunk/yat/utility/StrideIterator.h (modified) (5 diffs)

trunk/yat/utility/StrideIterator.h

@@ -27 +27 @@
 
 #include "iterator_traits.h"
-#include "yat_assert.h"
 
 #include <boost/iterator/iterator_adaptor.hpp>
-
-#include <iterator>
-#include <stdexcept>
 
 namespace theplu {
@@ -92 +88 @@
   template<typename Iter>
   class StrideIterator 
-    : public std::iterator<typename std::iterator_traits<Iter>::iterator_category, 
-                           typename std::iterator_traits<Iter>::value_type, 
-                           typename std::iterator_traits<Iter>::difference_type, 
-                           typename std::iterator_traits<Iter>::pointer, 
-                           typename std::iterator_traits<Iter>::reference>
+    : public boost::iterator_adaptor<StrideIterator<Iter>, Iter>
   {
   public:
@@ -117 +109 @@
        Using default constructor of BASE iterator.
      */
-    StrideIterator(difference_type stride=1)
-      : stride_(stride) {}
+    StrideIterator(size_t stride=1)
+      : StrideIterator::iterator_adaptor_(), stride_(stride) {}
 
     /**
        \brief Constructor
     */
-    explicit StrideIterator(Iter p, difference_type stride=1)
-      : iterator_(p), stride_(stride) {}
+    explicit StrideIterator(Iter p, size_t stride=1)
+      : StrideIterator::iterator_adaptor_(p), stride_(stride) {}
 
     
@@ -137 +129 @@
     StrideIterator(StrideIterator<I2> other,
                    typename boost::enable_if_convertible<I2, Iter>::type* = 0 )
-      : iterator_(other.base()), stride_(other.stride()) {}
-
-    /**
-       \return underlying iterator
-     */
-    inline Iter base(void) const { return iterator_; }
+      : StrideIterator::iterator_adaptor_(other.base()), 
+        stride_(other.stride()) {}
 
     /**
@@ -149 +137 @@
     inline size_t stride(void) const { return stride_; }
 
-    /**
-       \return element
-     */
-    reference operator*(void) const 
-    { return *iterator_; }
+  private:
+    // to give base class access to private parts
+    friend class boost::iterator_core_access;
+    
+    size_t stride_;
 
-    /**
-       \return pointer
-     */
-    pointer operator->() const { return &(operator*()); }
+    typedef typename StrideIterator::iterator_adaptor_::difference_type
+    difference_t;
 
-    /**
-       \return element \a n steps forward
-     */
-    reference operator[](difference_type n) const 
-    { 
-      return iterator_[stride_*n];
-    }
+    void advance(difference_t n){ this->base_reference() += stride_*n; }
+    void decrement(void) { this->base_reference()-=stride_; }
 
-    /**
-       \brief pre-increment
+    template <class OtherIterator>
+    difference_t distance_type(const StrideIterator<OtherIterator>& other) const
+    { return (other.base() - this->base())/stride_; }
 
-       \return reference to *this
-     */
-    StrideIterator& operator++(void) { iterator_+=stride_; return *this; }
-
-    /**
-       \brief post-increment
-
-       \return copy of iterator prior increment
-     */
-    StrideIterator operator++(int) 
-    { StrideIterator tmp(*this); iterator_+=stride_; return tmp;}
-
-    /**
-       \brief iterate \f$ n \f$ steps forward
-
-       \return reference to resulting iterator
-     */
-    StrideIterator& operator+=(int n) { iterator_+=stride_*n; return *this; }
-
-    /**
-       \brief post-decrement
-
-       \return copy of iterator prior decrement
-     */
-    StrideIterator operator--(int) 
-    { StrideIterator tmp(*this); iterator_-=stride_; return tmp;}
-
-    /**
-       \brief pre-decrement
-
-       \return reference to resulting iterator
-     */
-    StrideIterator& operator--(void) { iterator_-=stride_; return *this; }
-
-    /**
-       \brief iterate \f$ n \f$ steps backwards
-
-       \return reference to resulting iterator
-     */
-    StrideIterator& operator-=(int n) { iterator_-=n*stride_; return *this; }
-
-    /**
-       \brief addition operator
-
-       \return copy of resulting iterator
-     */
-    friend StrideIterator operator+(const StrideIterator& lhs,difference_type n) 
-    { StrideIterator tmp(lhs); tmp+=n; return tmp; }
-
-    /**
-       \brief subtraction operator
-
-       \return copy of resulting iterator
-     */
-    friend StrideIterator operator-(const StrideIterator& lhs, 
-                                    difference_type n) 
-    { StrideIterator tmp(lhs); tmp-=n; return tmp; }
-
-    /**
-       \brief difference operator
-
-       \return distance between \a lhs and \a rhs
-     */
-    friend difference_type operator-(const StrideIterator& lhs, 
-                                     const StrideIterator& rhs) 
-    {
-      yat_assert<std::runtime_error>(lhs.stride_==rhs.stride_, 
-        "StrideIterator::operator- different stride in lhs and rhs.");
-      return static_cast<difference_type>( (lhs.iterator_-rhs.iterator_)/
-                                           lhs.stride_);
-    }
-
-    
-    /**
-       \brief Equality operator
-
-       \return True if \a lhs and \a rhs are pointing to same element
-     */
-    friend bool operator==(const StrideIterator& lhs, const StrideIterator& rhs)
-    { return lhs.iterator_==rhs.iterator_; }
-    
-    /**
-       \brief Non-equality operator
-
-       \return False if \a lhs and \a rhs are pointing to same element
-     */
-    friend bool operator!=(const StrideIterator& lhs, const StrideIterator& rhs)
-    { return lhs.iterator_!=rhs.iterator_; }
-    
-    /**
-       \brief Less operator
-     */
-    friend bool operator<(const StrideIterator& lhs, const StrideIterator& rhs)
-    { return lhs.iterator_<rhs.iterator_; }
-    
-    /**
-       \brief Less equal operator
-     */
-    friend bool operator<=(const StrideIterator& lhs, const StrideIterator& rhs)
-    { return lhs.iterator_<=rhs.iterator_; }
-    
-    /**
-       \brief Larger operator
-     */
-    friend bool operator>(const StrideIterator& lhs, const StrideIterator& rhs)
-    { return lhs.iterator_>rhs.iterator_; }
-    
-    /**
-       \brief Larger equal operator
-     */
-    friend bool operator>=(const StrideIterator& lhs, const StrideIterator& rhs)
-    { return lhs.iterator_>=rhs.iterator_; }
-    
-  private:
-    Iter iterator_;
-    size_t stride_;
+    void increment(void) { this->base_reference()+=stride_; }
 
     // Using compiler generated copy