Changeset 1541 for trunk/yat/utility/iterator_traits.h

Timestamp:

Sep 30, 2008, 7:40:41 PM (13 years ago)

Author:

Peter

Message:

fixes #445 so iterator_traits detects when value_type is DataWeight?
and return weighted_iterator_tag. Also weighted_iterator_traits
recognize some normal cases; when reference_type is DataWeight?& or
const DataWeight?& weighted behaviour is performed.

Fixed some incorrect inclusion in WeightedIterator? and removed debug
code in StrideIterator?.

File:

• trunk/yat/utility/iterator_traits.h (modified) (3 diffs)

trunk/yat/utility/iterator_traits.h

@@ -27 +27 @@
 
 #include <iterator>
-#include <vector>
 
 namespace theplu {
@@ -47 +46 @@
   struct weighted_iterator_tag {};
 
+
+  /**
+     \internal
+
+     used in weighted_iterator_traits
+  */
+  template <typename T>
+  struct weighted_iterator_traits_detail {
+    /**
+       default is a iterator unweighted
+    */
+    typedef unweighted_iterator_tag type;
+  };  
+
+  /** 
+      \internal
+
+      specialization for iterators with value type DataWeight
+  */
+  template <>
+  struct weighted_iterator_traits_detail<DataWeight> {
+    /**
+       Iterators with value type DataWeight is weighted
+     */
+    typedef weighted_iterator_tag type;
+  };  
+
   /** 
-      All iterators default to unweighted type. If you want your
-      iterator to behave as weighted, you need to provide a
-      specialization.
-
-      \see Iterator and StrideIterator
+      Metafunction to decide whether an iterator is weighted or
+      non-weighted. This (default) implementation return unweighted,
+      unless value_type of iterator is DataWeight in which case
+      weighted is returned.
   */
   template <class T>
-  struct weighted_iterator_traits {
-  /** 
-      All iterators default to unweighted type
-  */
-    typedef unweighted_iterator_tag type;
-  };
-
-  /**
-     Specialization for std::vector<DataWeight>::iterator
-   */
-  template<>
-  struct weighted_iterator_traits<std::vector<DataWeight>::iterator> {
-    /**
-       iterator to vector<DataWeight> is weighted
-    */
-    typedef weighted_iterator_tag type;
-  };
-
-
-  /**
-     Specialization for std::vector<DataWeight>::const_iterator
-   */
-  template<>
-  struct weighted_iterator_traits<std::vector<DataWeight>::const_iterator> {
-    /**
-       const_iterator to vector<DataWeight> is weighted
-    */
-    typedef weighted_iterator_tag type;
+  struct weighted_iterator_traits 
+  {
+  private:
+    typedef typename std::iterator_traits<T>::value_type value;
+  public:
+    /**
+       \return weighted if value_type is DataWeight
+     */
+    typedef typename weighted_iterator_traits_detail<value>::type type;
   };
 
@@ -158 +164 @@
 
   /**
-     \brief traits to make unweighted iterator work as in a weighted
-
-     This class must be implemented for every iterator that can be weighted.
-
-     \see StrideIterator and Container2DIterator
+     \internal
+
+     This class is used in iterator_traits to separate different cases. 
+
+     This the default implementation that could be used for unweighted
+     iterators.
+   */
+  template <typename Iter, typename T >
+  struct iterator_traits_detail 
+  {
+    /**
+       for unweighted data_reference is reference
+    */
+    typedef typename std::iterator_traits<Iter>::reference data_reference;
+
+    /**
+       for unweighted weight_reference is a double
+    */
+    typedef double weight_reference;
+
+    /**
+       Constructor just checking that iterator is unweighted
+    */
+    iterator_traits_detail(void) 
+    { check_iterator_is_unweighted(typename 
+                                   weighted_iterator_traits<Iter>::type());
+    }
+    
+    /**
+       \return * \a iter 
+    */
+    data_reference data(Iter iter) const { return *iter; }
+
+    /**
+       \return 1.0
+    */
+    weight_reference weight(Iter iter) const { return 1.0; }
+  };
+
+
+  /**
+     specialization for weighted iterator with reference DataWeight&
+   */
+  template <typename Iter>
+  struct iterator_traits_detail<Iter, DataWeight&> {
+    /**
+       for mutable weighted iterator data_reference is double&
+    */
+    typedef double& data_reference;
+
+    /**
+       for mutable weighted iterator weight_reference is double&
+    */
+    typedef double& weight_reference;
+
+    /**
+       \return reference to data of iterator
+    */
+    data_reference data(Iter iter) const { return iter->data(); }
+
+    /**
+       \return reference to weight of iterator
+    */
+    weight_reference weight(Iter iter) const { return iter->weight(); }
+  };
+
+
+  /**
+     specialization for weighted iterator with reference const DataWeight&
+   */
+  template <typename Iter>
+  struct iterator_traits_detail<Iter, const DataWeight&> {
+    /**
+       for read-only weighted iterator data_reference is const double&
+    */
+    typedef const double& data_reference;
+
+    /**
+       for read-only weighted iterator data_reference is const double&
+    */
+    typedef const double& weight_reference;
+
+    /**
+       \return const reference to data of iterator
+    */
+    data_reference data(Iter iter) const { return iter->data(); }
+
+    /**
+       \return const reference to weight of iterator
+    */
+    weight_reference weight(Iter iter) const { return iter->weight(); }
+  };
+
+
+  /**
+     The purpose of this class is to allow polymorphism between
+     weighted and unweighted iterators. It allows to access data and
+     weight for both weighted and unweighted iterators.
+
+     This class works for unweighted iterators as well as weighted
+     iterators as long as they have reference type DataWeight& or
+     const DataWeight&.
+
+     For others, such as WeightedIterator for which reference type is
+     a proxy class, this class should be specialized. For adaptors
+     that have an underlying iterator (e.g. StrideIterator), this
+     class should be specialized, so the class also works when the
+     underlying is an iterator that is not overed by this class
+     e.g. WeightedIterator.
    */ 
-  template <class Iter>
+  template <typename Iter>
   struct iterator_traits {
-    /**
-       \brief Default constructor
-
-       Does nothing but check that Iter is unweighted (at compile time).
-     */
-    iterator_traits(void)
-    { 
-      check_iterator_is_unweighted(typename weighted_iterator_traits<Iter>::type()); }
-
-    /**
-       An unweighted iterator has data_reference = reference
-     */
-    typedef typename std::iterator_traits<Iter>::reference data_reference;
-
-    /**
-       An unweighted iterator has a weight = 1.0 and since this is a
-       temporary it is returned by value and weight_reference is double
-     */
-    typedef double weight_reference;
-
-    /**
-       \return data that is *iter
+  private:
+    typedef typename std::iterator_traits<Iter>::reference reference;
+    typedef iterator_traits_detail<Iter, reference> traits;
+  public:
+    /**
+       data_reference (type returned by data(void) is determined by
+       iterator_traits_detail
+     */
+    typedef typename traits::data_reference data_reference;
+
+    /**
+       data_reference (type returned by data(void) is determined by
+       iterator_traits_detail
+     */
+    typedef typename traits::weight_reference weight_reference;
+
+    /**
+       \return data
     */
     data_reference data(Iter iter) const 
-    { check_iterator_is_unweighted(iter); return *iter; }
-
-    /**
-       \return 1.0
-    */
+    { return traits().data(iter); }
+
+    /**
+       \return 
+     */
     weight_reference weight(Iter iter) const 
-    { check_iterator_is_unweighted(iter); return 1.0; }
-
-  };
-
-
-  /**
-     Specialization for std::vector<DataWeight>::iterator
-   */ 
-  template <>
-  struct iterator_traits<std::vector<DataWeight>::iterator> {
-    /**
-       mutable iterator
-     */
-    typedef double& data_reference;
-
-    /**
-       mutable iterator
-     */
-    typedef double& weight_reference;
-
-    /**
-       \return data using DataWeight::data()
-    */
-    data_reference data(std::vector<DataWeight>::iterator iter) const 
-    { return iter->data(); }
-
-    /**
-       \return weight using DataWeight::weight()
-    */
-    weight_reference weight(std::vector<DataWeight>::iterator iter) const 
-    { return iter->weight(); }
-
-  };
-
-
-  /**
-     Specialization for std::vector<DataWeight>::const_iterator
-   */ 
-  template <>
-  struct iterator_traits<std::vector<DataWeight>::const_iterator> {
-    /**
-       const iterator
-     */
-    typedef const double& data_reference;
-
-    /**
-       const iterator
-     */
-    typedef const double& weight_reference;
-
-    /**
-       \return data using DataWeight::data()
-    */
-    data_reference data(std::vector<DataWeight>::iterator iter) const 
-    { return iter->data(); }
-
-    /**
-       \return weight using DataWeight::weight()
-    */
-    weight_reference weight(std::vector<DataWeight>::iterator iter) const 
-    { return iter->weight(); }
-
-  };
+    { return traits().weight(iter); }
+
+  };
+
 
 }}} // of namespace utility, yat, and theplu