Changeset 1537 for trunk/yat

Timestamp:

Sep 27, 2008, 12:37:33 AM (15 years ago)

Author:

Peter

Message:

refs #368 - redesign to solve some issues regarding mutable functionality in WeightedIterator?

Location:

trunk/yat/utility

Files:

• DataWeightProxy.cc (deleted)
• DataWeightProxy.h (modified) (2 diffs)
• Makefile.am (modified) (1 diff)
• WeightedIterator.h (modified) (5 diffs)

trunk/yat/utility/DataWeightProxy.h

@@ -33 +33 @@
 
      \brief Proxy class for DataWeight
+
+     DataIterator and WeightIterator should be a TrivialIterator
   */
+  template<typename DataIterator, typename WeightIterator>
   class DataWeightProxy
   {
@@ -40 +43 @@
        \brief Default constructor
 
-       \param data data value to hold
-       \param weight weight value to hold
+       \param data iterator pointing to data to hold
+       \param weight iterator pointing to weight to hold
      */
-    DataWeightProxy(double& data, double& weight);
+    DataWeightProxy(DataIterator data, WeightIterator weight)
+      : data_(data), weight_(weight) {}
 
     /**
        \return reference to data
      */
-    double& data(void);
+    double& data(void) { return *data_; }
 
     /**
        \return const reference to data
      */
-    const double& data(void) const;
+    const double& data(void) const { return *data_ ; }
 
     /**
        \return reference to weight
      */
-    double& weight(void);
+    double& weight(void) { return *weight_; }
 
     /**
        \return const reference to weight
      */
-    const double& weight(void) const;
+    const double& weight(void) const { return *weight_; }
 
     /**
        \brief assignment operator
      */
-    DataWeightProxy& operator=(const DataWeight& rhs);
+    DataWeightProxy& operator=(const DataWeight& rhs)
+    {
+      data() = rhs.data();
+      weight() = rhs.weight();
+      return *this;
+    }
 
     /**
        \brief Conversion to DataWeight
      */
-    operator DataWeight() const;
+    operator DataWeight() const { return DataWeight(data(), weight()); }
 
   private:
-    double& data_;
-    double& weight_;
+    DataIterator data_;
+    WeightIterator weight_;
 
-    // no copying
-    DataWeightProxy(const DataWeightProxy&);
-    DataWeightProxy& operator=(const DataWeightProxy&);
+    // using compiler generated copy and assignment
+    //DataWeightProxy& operator=(const DataWeightProxy&);
+    //DataWeightProxy(const DataWeightProxy&);
   };
+
+  
+  /**
+     \brief equality operator
+   */
+  template<typename DataIterator, typename WeightIterator>
+  bool operator==(const DataWeightProxy<DataIterator, WeightIterator>& lhs,
+                  const DataWeightProxy<DataIterator, WeightIterator>& rhs)
+  {
+    return lhs.data()==rhs.data() && lhs.weight()==rhs.weight();
+  }
 
 }}} // of namespace utility, yat, and theplu

trunk/yat/utility/Makefile.am

@@ -23 +23 @@
 noinst_LTLIBRARIES = libutility.la
 libutility_la_SOURCES = \
-  Alignment.cc ColumnStream.cc CommandLine.cc DataWeight.cc DataWeightProxy.cc \
+  Alignment.cc ColumnStream.cc CommandLine.cc DataWeight.cc \
   FileUtil.cc Index.cc kNNI.cc \
   Matrix.cc MatrixWeighted.cc NNI.cc Option.cc \

trunk/yat/utility/WeightedIterator.h

@@ -23 +23 @@
 */
 
+#include <DataWeight.h>
+#include <DataWeightProxy.h>
+
 #include <boost/iterator/iterator_facade.hpp>
 
@@ -32 +35 @@
 
   /**
-     @brief WeightedIterator
+     \brief WeightedIterator
   */
   template<typename DataIterator, typename WeightIterator>
@@ -39 +42 @@
     WeightedIterator<DataIterator, WeightIterator>,
     DataWeight,
-    std::random_access_iterator_tag,
-    DataWeight>
+    typename std::iterator_traits<DataIterator>::iterator_category,
+    DataWeightProxy<DataIterator, WeightIterator> >
     
   {
@@ -50 +53 @@
       : d_iter_(d), w_iter_(w)
     {}
+    
+
+    /**
+       \brief element operator
+     */
+    DataWeightProxy<DataIterator, WeightIterator> operator[](int n) const
+    {
+      return DataWeightProxy<DataIterator, WeightIterator>(d_iter_+n, 
+                                                           w_iter_+n); 
+    }     
+    
 
     /**
        \brief Conversion constructor. 
-
+       
        Create a WeightIterator<Base> from a
        WeightIterator<B2>. Possible if B2 is convertible to a
@@ -72 +86 @@
     DataIterator d_iter_;
     WeightIterator w_iter_;
-
+    
     void advance(size_t n)
     { std::advance(d_iter_, n); std::advance(w_iter_, n); }
 
     void decrement(void) { --d_iter_; --w_iter_; }
-
+    
     typename std::iterator_traits<DataIterator>::difference_type 
     distance_to(const WeightedIterator& other) const
     { return std::distance(d_iter_, other.d_iter_); }
 
-    DataWeight dereference(void) const 
-    { return DataWeight(*d_iter_, *w_iter_); }
+    utility::DataWeightProxy<DataIterator, WeightIterator> 
+    dereference(void) const 
+    { 
+      return DataWeightProxy<DataIterator, WeightIterator>(d_iter_, 
+                                                           w_iter_); 
+    }
 
     bool equal(const WeightedIterator& other) const