Changeset 1538

Timestamp:

Sep 27, 2008, 6:27:55 AM (15 years ago)

Author:

Peter

Message:

refs #368 - added several tests. Left now is to add specializations for trait classes.

Location:

trunk

Files:

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

trunk/test/data_weight_proxy_test.cc

@@ -35 +35 @@
       : proxy_(proxy) {}
 
+    inline Proxy get_copy(void) { return proxy_; }
     inline Proxy& operator()(void) { return proxy_; }
     inline const Proxy& operator()(void) const 
@@ -95 +96 @@
   suite.add(suite.equal(xw3.weight(), 0.5));
 
+  DataWeight xw4(1.602, 1);
+  holder.get_copy() = xw4;
+  suite.add(suite.equal(holder().data(), 1.602));
+  suite.add(suite.equal(holder().weight(), 1));
+
   return suite.return_value();
 }

trunk/test/iterator_test.cc

@@ -423 +423 @@
   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));
-}
+  std::vector<double> data(vec.size());
+  std::vector<double> weight(vec.size());
+  WIter iter2(data.begin(), weight.begin());
+  utility::DataWeight tmp2(6.89, 0.79);
+  *iter2 = tmp2;
+  if (!suite.add(tmp2==*iter2))
+    suite.err() << "error: tmp2==*iter2" << std::endl;
+  utility::DataWeight tmp3(*iter2);
+  suite.add(suite.equal(tmp3.data(), tmp2.data()));
+  suite.add(suite.equal(tmp3.weight(), tmp2.weight()));
+  *iter2 = *iter;
+  if (!suite.add(*iter2 == *iter))
+    suite.err() << "error: *iter2 == *iter\n";
+  tmp = *iter2;
+  suite.add(suite.equal(tmp.data(), 1));
+  std::copy(iter, iter+3, iter2);
+  suite.add(suite.equal(vec.front(), 1));
+  suite.add(suite.equal(data.front(), 1));
+
+  suite.err() << "  testing const conversion\n";
+  typedef std::vector<double>::const_iterator const_Iter;
+  typedef utility::WeightedIterator<const_Iter, const_Iter> const_WIter;
+  const_WIter const_iter(vec.begin(), vec.begin());
+  const_iter = iter;
+  
+  suite.err() << "  testing assignment between different iterators\n";
+  const std::vector<double> const_vec(10, 10.7);
+  const_WIter const_iter2(const_vec.begin(), const_vec.begin());
+  utility::DataWeight tmp4;
+  tmp4 = *const_iter2;
+  *iter = *const_iter2;
+  suite.add(*iter==*const_iter2);
+  *iter = *const_iter;
+  suite.add(*iter==*const_iter);
+
+  double x=101;
+  utility::WeightedIterator<double*, double*> iter_p(&x, &x);
+  *iter_p = *iter;
+  suite.add(*iter_p==*iter);  
+}

trunk/yat/utility/DataWeightProxy.h

@@ -52 +52 @@
        \return reference to data
      */
+    //typename std::iterator_traits<DataWeight>::reference data(void) const
     double& data(void) { return *data_; }
 
@@ -72 +73 @@
        \brief assignment operator
      */
+    DataWeightProxy& operator=(const DataWeightProxy& rhs)
+    {
+      data() = rhs.data();
+      weight() = rhs.weight();
+      return *this;
+    }
+
+    /**
+       \brief assignment operator
+     */
     DataWeightProxy& operator=(const DataWeight& rhs)
     {
@@ -82 +93 @@
        \brief Conversion to DataWeight
      */
-    operator DataWeight() const { return DataWeight(data(), weight()); }
+    operator DataWeight() const 
+    { return DataWeight(this->data(), this->weight()); }
 
   private:

trunk/yat/utility/WeightedIterator.h

@@ -41 +41 @@
     : public boost::iterator_facade<
     WeightedIterator<DataIterator, WeightIterator>,
-    DataWeight,
+    DataWeightProxy<DataIterator, WeightIterator>,
     typename std::iterator_traits<DataIterator>::iterator_category,
     DataWeightProxy<DataIterator, WeightIterator> >
@@ -47 +47 @@
   {
   public:
+    /**
+       \brief DataIterator
+     */
+    typedef DataIterator data_iterator_type;
+
+    /**
+       \brief DataIterator
+     */
+    typedef WeightIterator weight_iterator_type;
+
     /**
        \brief Constructor
@@ -54 +64 @@
     {}
     
+    /**
+       \return const reference to underlying data iterator
+     */
+    const DataIterator& data_base(void) const { return d_iter_; }
+
+    /**
+       \return const reference to underlying weight iterator
+     */
+    const WeightIterator& weight_base(void) const { return w_iter_; }
 
     /**
@@ -73 +92 @@
        to const_iterator.
      */
-    /*
     template<typename D2, typename W2>
     WeightedIterator(WeightedIterator<D2, W2> other,
             typename boost::enable_if_convertible<D2,DataIterator>::type* = 0,
             typename boost::enable_if_convertible<W2,WeightIterator>::type* = 0)
-    {}
-    */
+      : d_iter_(other.data_base()), w_iter_(other.weight_base()) {}
+
 
   private:
@@ -98 +116 @@
     utility::DataWeightProxy<DataIterator, WeightIterator> 
     dereference(void) const 
-    { 
-      return DataWeightProxy<DataIterator, WeightIterator>(d_iter_, 
+    { return DataWeightProxy<DataIterator, WeightIterator>(d_iter_, 
                                                            w_iter_); 
     }