Changeset 3393

Timestamp:

Mar 17, 2015, 4:38:36 AM (8 years ago)

Author:

Peter

Message:

refs #803

The std::random_access_iterator promises that iterator provides random
traversal and that reference_type is an lvalue (i.e. not proxy). If
reference_type is a proxy, it is therefore incorrect to tag the
iterator with std::random_access_iterator. To reflect that we do the
following two changes:

1) Container2DIterator now carries tag
boost::random_access_traversal_tag rather than
std::random_access_iterator. This means that in std:: speak a
Container2DIterator is a random access iterator, if reference is an
lvalue and an input iterator otherwise.

2) The BASE of StrideIterator? is no longer required to be a random
access iterator, instead we require random access traversal.
Therefore, StrideIterator? now uses the default tag rather than
std::iterator_traits<BASE>::iterator_category. This means that the
traversal tag is boost::random_access_traversal_tag (as BASE is
required to provide random access traversal), and in std:: speak the
same rule applies as for Container2DIterator.

3) The concept check for Container2D now requires that iterators
::const_iterator, ::const_row_iterator, ::const_column_iterator are
readable iterator (the random access requirement is removed).

Location:

trunk

Files:

• NEWS (modified) (1 diff)
• test/iterator.cc (modified) (1 diff)
• yat/utility/Container2DIterator.h (modified) (1 diff)
• yat/utility/StrideIterator.h (modified) (3 diffs)
• yat/utility/concept_check.h (modified) (2 diffs)

trunk/NEWS

@@ -8 +8 @@
   - AveragerWeighted::n(void) now return 0, when object is empty (ticket #802)
   - added support for htslib (see ticket #794)
+  - Container2DIterator is now tagged with
+    boost::random_access_traversal_tag (see ticket #803, r3393)
+  - StrideIterator is now tagged with use_default (see ticket #803, r3393)
 
   A complete list of closed tickets can be found here [[br]]

trunk/test/iterator.cc

@@ -499 +499 @@
     x *= 2; // avoid compiler warning
 
-    // ticket #623
+    // ticket #623 is about iterator below did not pass boost concept
+    // check as a random access iterator.
     typedef utility::Container2DIterator<const classifier::KernelLookup, 
       double, const double> c2dIter;
-    BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<c2dIter>));
+    // The workaround in #623 is dirty as it circumvent the fact that
+    // random access iterators are required to return lvalue from
+    // operator*. This is further explained in //
+    // http://www.boost.org/doc/libs/1_57_0/libs/iterator/doc/index.html
+    // and ticket #803. So here we replace the check for C++98 style
+    // random access iterator with boost style readable and
+    // random_access_traversal.
+    //BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<c2dIter>));
+    BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<c2dIter>));
+    BOOST_CONCEPT_ASSERT((boost_concepts::RandomAccessTraversal<c2dIter>));
 
     typedef StrideIterator<c2dIter> StrideIter;
-    StrideIter::iterator_category x623;
-    std::random_access_iterator_tag y623(x623);
-    BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<StrideIter>));
+    BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<StrideIter>));
+    BOOST_CONCEPT_ASSERT((boost_concepts::RandomAccessTraversal<StrideIter>));
+
+    // the minimal requirement for BASE is that BASE is random access traversal
+    typedef int value_type;
+    typedef boost::iterator_archetypes::readable_iterator_t access_type;
+    typedef boost::random_access_traversal_tag traversal;
+    typedef boost::iterator_archetype<value_type, access_type, traversal> Base;
+    StrideIterator<Base> si;
   }
 }

trunk/yat/utility/Container2DIterator.h

@@ -63 +63 @@
     Container2DIterator<Container, value, reference>
     , value
-    , std::random_access_iterator_tag
+    , boost::random_access_traversal_tag
     , reference>
   {

trunk/yat/utility/StrideIterator.h

@@ -26 +26 @@
 #include <boost/concept_check.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_concepts.hpp>
 
 namespace theplu {
@@ -41 +42 @@
      by combining StrideIterator with a reverse_iterator (from
      e.g. std or boost).
+
+     Type Requirements:
+     - \c RandomAccessIterator must be a \readable_iterator
+     - \c RandomAccessIterator must be a \random_access_traversal_iterator
   */
   template<typename RandomAccessIterator>
   class StrideIterator 
     : public boost::iterator_adaptor<StrideIterator<RandomAccessIterator>
-                                     , RandomAccessIterator
-                                     , boost::use_default
-      , typename std::iterator_traits<RandomAccessIterator>::iterator_category>
+                                     , RandomAccessIterator>
   {
     typedef boost::iterator_adaptor<StrideIterator<RandomAccessIterator>,
-                                    RandomAccessIterator,
-                                    boost::use_default,
-      typename std::iterator_traits<RandomAccessIterator>::iterator_category>
+                                    RandomAccessIterator>
     super_t;
 
@@ -67 +68 @@
       : StrideIterator::iterator_adaptor_(), stride_(stride) 
     {
-      BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<RandomAccessIterator>));
+      using boost_concepts::RandomAccessTraversal;
+      using boost_concepts::ReadableIterator;
+      BOOST_CONCEPT_ASSERT((ReadableIterator<RandomAccessIterator>));
+      BOOST_CONCEPT_ASSERT((RandomAccessTraversal<RandomAccessIterator>));
     }
 

trunk/yat/utility/concept_check.h

@@ -30 +30 @@
 #include <boost/concept_archetype.hpp>
 #include <boost/concept_check.hpp>
+#include <boost/iterator/iterator_concepts.hpp>
 
 namespace theplu {
@@ -89 +90 @@
       n = t_.columns();
       some_func(n);
-      BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<const_iterator>));
-      BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<const_row_iterator>));
-      BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<const_column_iterator>));
+      using boost_concepts::ReadableIterator;
+      BOOST_CONCEPT_ASSERT((ReadableIterator<const_iterator>));
+      BOOST_CONCEPT_ASSERT((ReadableIterator<const_row_iterator>));
+      BOOST_CONCEPT_ASSERT((ReadableIterator<const_column_iterator>));
     }