Changeset 1537

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

Files:

• test/data_weight_proxy_test.cc (modified) (2 diffs)
• test/iterator_test.cc (modified) (3 diffs)
• yat/utility/DataWeightProxy.cc (deleted)
• yat/utility/DataWeightProxy.h (modified) (2 diffs)
• yat/utility/Makefile.am (modified) (1 diff)
• yat/utility/WeightedIterator.h (modified) (5 diffs)

trunk/test/data_weight_proxy_test.cc

@@ -31 +31 @@
   {
   public:
-    ProxyHolder(utility::DataWeightProxy& proxy)
+    typedef utility::DataWeightProxy<double*, double*> Proxy;
+    ProxyHolder(Proxy& proxy)
       : proxy_(proxy) {}
 
-    inline utility::DataWeightProxy& operator()(void) { return proxy_; }
-    inline const utility::DataWeightProxy& operator()(void) const 
+    inline Proxy& operator()(void) { return proxy_; }
+    inline const Proxy& operator()(void) const 
     { return proxy_; }
   private:
-    utility::DataWeightProxy& proxy_;
+    Proxy& proxy_;
   };
 }}}
@@ -49 +50 @@
   suite.err() << "testing DataWeightProxy" << std::endl;
 
-  using utility::DataWeightProxy;
   using utility::DataWeight;
+
+  typedef utility::DataWeightProxy<double*, double*> Proxy;
 
   double x=1.2;
   double w=3.14;
   DataWeight xw(x, w);
-  DataWeightProxy proxy(x,w);
+  Proxy proxy(&x,&w);
   if (xw != proxy) {
     suite.add(false);

trunk/test/iterator_test.cc

@@ -27 +27 @@
 #include "yat/classifier/MatrixLookupWeighted.h"
 #include "yat/utility/Container2DIterator.h"
+#include "yat/utility/DataWeight.h"
 #include "yat/utility/DataIterator.h"
 #include "yat/utility/Matrix.h"
@@ -377 +378 @@
   suite.add(! (iter7<iter));
 
+  typename RandomAccessIterator::value_type tmp = iter[0];
+  typename RandomAccessIterator::value_type tmp2 = *iter;
+  tmp = tmp; // avoid compiler warning
+  if (!suite.add(tmp == tmp2))
+    suite.err() << "operator[] failed" << std::endl;
   if (!suite.add(iter[0] == *iter))
     suite.err() << "operator[] failed" << std::endl;
@@ -410 +416 @@
   std::vector<double> vec(3,1);
   typedef std::vector<double>::iterator Iter;
-  utility::WeightedIterator<Iter, Iter> iter(vec.begin(), vec.begin());
-
+  typedef utility::WeightedIterator<Iter, Iter> WIter;
+  WIter iter(vec.begin(), vec.begin());
+
+  utility::DataWeight tmp = *iter;
+
+  test_bidirectional_iterator(iter, suite);
   test_random_access_iterator(iter, suite);
-
-}
+  //std::vector<double> data(vec.size());
+  //std::vector<double> weight(vec.size());
+  //WIter iter2(data.begin(), weight.begin());
+  //  std::copy(iter, iter+3, iter2);
+  //suite.add(suite.equal(data.front(), 1));
+}

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