Changeset 881

Timestamp:

Sep 22, 2007, 10:22:36 PM (16 years ago)

Author:

Peter

Message:

merged constIterator into Iterator and added an extra template parameter. There are problems with conversion from iterator to const_iterator

Location:

trunk

Files:

• test/iterator_test.cc (modified) (1 diff)
• yat/classifier/DataLookup1D.h (modified) (1 diff)
• yat/utility/Iterator.h (modified) (3 diffs)
• yat/utility/Makefile.am (modified) (1 diff)
• yat/utility/constIterator.h (deleted)
• yat/utility/vector.h (modified) (1 diff)

trunk/test/iterator_test.cc

@@ -49 +49 @@
   classifier::DataLookup1D lookup(vec);
   utility::vector::iterator begin=vec.begin();
+  // test iterator to const_iterator conversion
+  utility::vector::const_iterator ci = vec.begin();
+  ci = begin;
+  //if (begin!=ci)
+  //ok = false;
+
   utility::vector::iterator end=vec.end();
   std::sort(begin, end);

trunk/yat/classifier/DataLookup1D.h

@@ -51 +51 @@
   public:
 
-    typedef utility::constIterator<const classifier::DataLookup1D> 
+    typedef utility::Iterator<const double, const classifier::DataLookup1D> 
     const_iterator;
 

trunk/yat/utility/Iterator.h

@@ -35 +35 @@
      @brief Iterator
   */
-  template<typename Container>
+  template<typename return_type, typename Container>
   class Iterator
   {
@@ -52 +52 @@
       : container_(&container), index_(index) {}
 
-    reference operator*(void) const { return container_->operator()(index_); }
+    return_type operator*(void) const { return container_->operator()(index_); }
     const Iterator& operator++(void) { ++index_; return *this; }
     Iterator operator++(int) 
-    { Iterator<Container> tmp(*this); ++index_; return tmp;}
+    { Iterator<return_type, Container> tmp(*this); ++index_; return tmp;}
     Iterator& operator+=(int n) { index_+=n; return *this; }
     Iterator operator+(int n) 
-    { return Iterator<Container>(*container_, index_+n); }
+    { return Iterator<return_type, Container>(*container_, index_+n); }
     Iterator operator--(int) 
-    { Iterator<Container> tmp(*this); --index_; return tmp;}
+    { Iterator<return_type, Container> tmp(*this); --index_; return tmp;}
     Iterator operator--(void) { --index_; return *this; }
     Iterator& operator-=(int n) { index_-=n; return *this; }
     Iterator operator-(size_t n) 
-    { return Iterator<Container>(*container_, index_-n); }
+    { return Iterator<return_type, Container>(*container_, index_-n); }
     size_t operator-(const Iterator& rhs) 
     { return index_-rhs.index_; }
 
-    bool equal(const Iterator<Container>& other) const
+    bool equal(const Iterator<return_type, Container>& other) const
     { return container_==other.container_ && index_==other.index_; }
 
-    bool less(const Iterator<Container>& other) const
+    bool less(const Iterator<return_type, Container>& other) const
     { return index_<other.index_; }
+
+    operator Iterator<const double, const Container> () 
+    { return Iterator<const double, const Container>(*container_, index_); } 
 
   private:
@@ -83 +86 @@
   };
 
-    template <typename T>
-    inline bool operator==(const Iterator<T>& lhs, 
-                           const Iterator<T>& rhs)
-    {
-      return lhs.equal(rhs);
-    }
+  template <typename T1, typename T2>
+  inline bool operator==(const Iterator<T1,T2>& lhs, 
+                         const Iterator<T1,T2>& rhs)
+  {
+    return lhs.equal(rhs);
+  }
 
-    template <typename T>
-    inline bool operator!=(const Iterator<T>& lhs, 
-                           const Iterator<T>& rhs)
-    {
-      return !(lhs==rhs);
-    }
-
-
-    template <typename T>
-    inline bool operator<(const Iterator<T>& lhs, 
-                          const Iterator<T>& rhs)
-    {
-      return lhs<rhs;
-    }
-
-
-    template <typename T>
-    inline bool operator<=(const Iterator<T>& lhs, 
-                           const Iterator<T>& rhs)
-    {
-      return !(rhs<lhs);
-    }
-
-
-    template <typename T>
-    inline bool operator>(const Iterator<T>& lhs, 
-                          const Iterator<T>& rhs)
-    {
-      return rhs<lhs;
-    }
-
-
-    template <typename T>
-    inline bool operator>=(const Iterator<T>& lhs, 
-                           const Iterator<T>& rhs)
-    {
-      return !(lhs<rhs);
-    }
+  template <typename T1, typename T2>
+  inline bool operator!=(const Iterator<T1,T2>& lhs, 
+                         const Iterator<T1,T2>& rhs)
+  {
+    return !(lhs==rhs);
+  }
+  
+  
+  template <typename T1, typename T2>
+  inline bool operator<(const Iterator<T1,T2>& lhs, 
+                        const Iterator<T1,T2>& rhs)
+  {
+    return lhs<rhs;
+  }
+  
+  
+  template <typename T1, typename T2>
+  inline bool operator<=(const Iterator<T1,T2>& lhs, 
+                         const Iterator<T1,T2>& rhs)
+  {
+    return !(rhs<lhs);
+  }
+  
+  
+  template <typename T1, typename T2>
+  inline bool operator>(const Iterator<T1,T2>& lhs, 
+                        const Iterator<T1,T2>& rhs)
+  {
+    return rhs<lhs;
+  }
+  
+  
+  template <typename T1, typename T2>
+  inline bool operator>=(const Iterator<T1,T2>& lhs, 
+                         const Iterator<T1,T2>& rhs)
+  {
+    return !(lhs<rhs);
+  }
 
 

trunk/yat/utility/Makefile.am

@@ -32 +32 @@
 
 include_utility_HEADERS = \
-  Alignment.h constIterator.h Exception.h FileUtil.h Iterator.h \
+  Alignment.h Exception.h FileUtil.h Iterator.h \
   kNNI.h matrix.h NNI.h \
   PCA.h stl_utility.h SVD.h TypeInfo.h utility.h vector.h WeNNI.h

trunk/yat/utility/vector.h

@@ -89 +89 @@
   public:
 
-    typedef Iterator<vector> iterator;
-    typedef constIterator<const vector> const_iterator;
+    typedef Iterator<double&, vector> iterator;
+    typedef Iterator<const double, const vector> const_iterator;
 
     /**