Changeset 1537 for trunk/yat/utility/DataWeightProxy.h

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?

File:

• trunk/yat/utility/DataWeightProxy.h (modified) (2 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