Completed merging of flatten and recursive iterator. Trivial test compiles.

flatten_iterator.hpp

@@ -1,207 +0,0 @@
-//
-//  flatten_iterator.hpp
-//  iterator
-//
-//  Created by Sam Jaffe on 2/17/17.
-//
-
-#pragma once
-
-#include "iterator_fwd.hpp"
-
-#include <tuple>
-
-namespace iterator {
-namespace detail {  
-  template <typename Iterator>
-  using flatten_iterator_base = end_aware_iterator< Iterator >;
-  
-  template <typename Iterator>
-  class flatten_iterator_terminal : flatten_iterator_base< Iterator > {
-  private:
-    using layer = flatten_iterator_base< Iterator >;
-    using first_type = typename layer::value_type::first_type;
-    using second_type = typename layer::value_type::second_type;
-  public:
-    using value_type = std::tuple<first_type, second_type>;
-    using reference = std::tuple<first_type &, second_type &>;
-//    using pointer = typename layer::pointer;
-    using difference_type = typename layer::difference_type;
-    using iterator_category = typename layer::iterator_category;
-  public:
-    flatten_iterator_terminal() = default;
-    flatten_iterator_terminal(layer v) : layer(v) {}
-    
-    reference operator*() {
-      return layer::operator*();
-    }
-    
-//    pointer operator->() {
-//      return layer::operator->();
-//    }
-    
-    bool operator==(flatten_iterator_terminal const & other) const {
-      return layer::operator==(other);
-    }
-  protected:
-    void next() {
-      layer::operator++();
-    }
-    
-    void assign(layer eat) {
-      static_cast<layer&>(*this) = eat;
-    }
-    
-    bool done() const { return layer::done(); }
-  };
-  
-  template <typename Iterator, typename RecursiveIterator_NextLayer>
-  class flatten_iterator_layer :
-  flatten_iterator_base< Iterator >,
-  RecursiveIterator_NextLayer {
-  private:
-    using next_layer = RecursiveIterator_NextLayer;
-    using layer = flatten_iterator_base< Iterator >;
-    
-    using key_type = typename layer::value_type::first_type;
-    using cat_value_type = typename next_layer::value_type;
-    using cat_reference = typename next_layer::reference;
-  public:
-    using value_type = decltype(std::tuple_cat(std::make_tuple(std::declval<key_type>()), std::declval<cat_value_type>()));
-    using reference = decltype(std::tuple_cat(std::tie(std::declval<key_type>()), std::declval<cat_reference>()));
-//    using pointer = typename next_layer::pointer;
-    using difference_type = typename next_layer::difference_type;
-    using iterator_category = typename next_layer::iterator_category;
-  public:
-    flatten_iterator_layer() = default;
-    flatten_iterator_layer(layer v) : layer(v), next_layer() {
-      if ( !v.done() ) {
-        next_layer::assign({ std::begin(v->second), std::end(v->second) });
-      }
-    }
-    
-    reference operator*() {
-      return std::tuple_cat(std::tie(layer::operator*().first), next_layer::operator*());
-    }
-    
-//    pointer operator->() {
-//      return next_layer::operator->();
-//    }
-    
-    bool operator==(flatten_iterator_layer const & other) const {
-      return layer::operator==(other) && next_layer::operator==(other);
-    }
-  protected:
-    void next() {
-      layer & self = static_cast<layer&>(*this);
-      next_layer::next();
-      while ( next_layer::done() && !(++self).done() ) {
-        next_layer::assign({ std::begin(self->second), std::end(self->second) });
-      }
-    }
-    
-    void assign(layer eat) {
-      static_cast<layer&>(*this) = eat;
-    }
-    
-    bool done() const { return layer::done(); }
-  };
-  
-  template <typename Iterator, std::size_t N, std::size_t Max, typename = void>
-  class bounded_flatten_iterator_impl :
-  public flatten_iterator_terminal< Iterator > {
-  private:
-    using super = flatten_iterator_terminal< Iterator >;
-  public:
-    using super::super;
-  };
-  
-  template <typename Iterator, std::size_t N, std::size_t Max>
-  class bounded_flatten_iterator_impl< Iterator, N, Max, typename std::enable_if<N < Max, typename void_t<mapped_iterator<Iterator>>::type>::type > :
-  public flatten_iterator_layer< Iterator , bounded_flatten_iterator_impl< mapped_iterator<Iterator>, N+1, Max > > {
-  private:
-    using next_layer = bounded_flatten_iterator_impl< mapped_iterator<Iterator>, N+1, Max >;
-    using super = flatten_iterator_layer< Iterator, next_layer >;
-  public:
-    using super::super;
-  };
-  
-  template <typename Iterator, typename = void>
-  class flatten_iterator_impl : public flatten_iterator_terminal< Iterator > {
-  private:
-    using super = flatten_iterator_terminal< Iterator >;
-  public:
-    using super::super;
-  };
-  
-  template <typename Iterator>
-  class flatten_iterator_impl< Iterator, typename void_t<mapped_iterator<Iterator>>::type > :
-  public flatten_iterator_layer< Iterator, flatten_iterator_impl< mapped_iterator<Iterator> > > {
-  private:
-    using next_layer = flatten_iterator_impl< mapped_iterator<Iterator> >;
-    using super = flatten_iterator_layer< Iterator, next_layer >;
-  public:
-    using super::super;
-  };
-}
-
-template <typename Iterator>
-class flatten_iterator : detail::flatten_iterator_impl< Iterator > {
-private:
-  using super = detail::flatten_iterator_impl< Iterator >;
-public:
-  using value_type = typename super::value_type;
-  using reference = typename super::reference;
-//  using pointer = typename super::pointer;
-  using difference_type = typename super::difference_type;
-  using iterator_category = typename super::iterator_category;
-public:
-  using super::super;
-  
-  flatten_iterator & operator++() {
-    (void) super::next();
-    return *this;
-  }
-  
-  flatten_iterator operator++(int) {
-    flatten_iterator tmp{*this};
-    (void) super::next();
-    return tmp;
-  }
-  
-  using super::operator*;
-//  using super::operator->;
-  using super::operator==;
-  bool operator!=(flatten_iterator const & other) { return !(operator==(other)); }
-};
-
-template <typename Iterator, std::size_t N>
-class flatten_iterator_n : detail::bounded_flatten_iterator_impl< Iterator, 1, N > {
-private:
-  using super = detail::bounded_flatten_iterator_impl< Iterator, 1, N >;
-public:
-  using value_type = typename super::value_type;
-  using reference = typename super::reference;
-//  using pointer = typename super::pointer;
-  using difference_type = typename super::difference_type;
-  using iterator_category = typename super::iterator_category;
-public:
-  using super::super;
-  
-  flatten_iterator_n & operator++() {
-    (void) super::next();
-    return *this;
-  }
-  
-  flatten_iterator_n operator++(int) {
-    flatten_iterator_n tmp{*this};
-    (void) super::next();
-    return tmp;
-  }
-  
-  using super::operator*;
-//  using super::operator->;
-  using super::operator==;
-  bool operator!=(flatten_iterator_n const & other) { return !(operator==(other)); }
-};
-}

iterator.xcodeproj/project.pbxproj

@@ -31,7 +31,6 @@
 		CD21AE2F1E4A428D00536178 /* end_aware_iterator.t.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = end_aware_iterator.t.h; sourceTree = "<group>"; };
 		CD7172E91E57C6580048DFFF /* recursive_iterator.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = recursive_iterator.hpp; sourceTree = "<group>"; };
 		CD7172EA1E57C91D0048DFFF /* recursive_iterator.t.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = recursive_iterator.t.h; sourceTree = "<group>"; };
-		CD7172EB1E57ED390048DFFF /* flatten_iterator.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = flatten_iterator.hpp; sourceTree = "<group>"; };
 		CD7172EC1E5897B80048DFFF /* iterator_fwd.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = iterator_fwd.hpp; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
@@ -81,7 +80,6 @@
 				CD21AE2E1E4A3F8E00536178 /* end_aware_iterator.hpp */,
 				CD21AE2C1E4A3EC100536178 /* join_iterator.hpp */,
 				CD7172E91E57C6580048DFFF /* recursive_iterator.hpp */,
-				CD7172EB1E57ED390048DFFF /* flatten_iterator.hpp */,
 			);
 			name = src;
 			sourceTree = "<group>";

recursive_iterator.hpp

@@ -11,34 +11,45 @@
 
 namespace iterator {
 namespace detail {  
-  template <typename Iterator>
-  using recursive_iterator_base = end_aware_iterator< Iterator >;
+//  template <typename Iterator>
+//  using recursive_iterator_base = end_aware_iterator< Iterator >;
   
+  template <typename Iterator, typename = void>
+  class recursive_iterator_base : public end_aware_iterator<Iterator> {
+  private:
+    using super = end_aware_iterator<Iterator>;
+  public:
+    using super::super;
+  };
+
   template <typename Iterator>
+  class recursive_iterator_base<Iterator, typename std::enable_if<std::is_const<typename end_aware_iterator<Iterator>::value_type::first_type>::value>::type> : public end_aware_iterator<Iterator> {
+  private:
+    using super = end_aware_iterator<Iterator>;
+    using first_type = typename super::value_type::first_type;
+    using second_type = typename super::value_type::second_type;
+  public:
+    using value_type = std::tuple<first_type, second_type>;
+    using reference = std::tuple<first_type &, second_type &>;
+  public:
+    using super::super;
+  };
+
+  template <typename Iterator, typename = void>
   class recursive_iterator_terminal : public recursive_iterator_base< Iterator > {
   private:
     using layer = recursive_iterator_base< Iterator >;
-  public:
-    using value_type = typename layer::value_type;
-    using reference = typename layer::reference;
-    using pointer = typename layer::pointer;
-    using difference_type = typename layer::difference_type;
-    using iterator_category = typename layer::iterator_category;
   public:
     recursive_iterator_terminal() = default;
     recursive_iterator_terminal(layer v) : layer(v) {}
     
-    reference operator*() {
+    typename layer::reference operator*() {
       return layer::operator*();
     }
     
-    pointer operator->() {
+    typename layer::pointer operator->() {
       return layer::operator->();
     }
-    
-    bool operator==(recursive_iterator_terminal const & other) const {
-      return layer::operator==(other);
-    }
   protected:
     void next() {
       layer::operator++();
@@ -99,6 +110,56 @@ namespace detail {
     bool done() const { return layer::done(); }
   };
   
+  template <typename Iterator, typename RecursiveIterator_NextLayer>
+  class flatten_iterator_layer :
+  recursive_iterator_base< Iterator >,
+  RecursiveIterator_NextLayer {
+  private:
+    using next_layer = RecursiveIterator_NextLayer;
+    using layer = recursive_iterator_base< Iterator >;
+    using key_type = typename std::tuple_element<0, typename layer::value_type>::type;
+  public:
+    using value_type = decltype(std::tuple_cat(std::make_tuple(std::declval<key_type>()), std::declval<typename next_layer::value_type>()));
+    using reference = decltype(std::tuple_cat(std::tie(std::declval<key_type>()), std::declval<typename next_layer::reference>()));
+    using pointer = void;
+    using difference_type = typename next_layer::difference_type;
+    using iterator_category = typename next_layer::iterator_category;
+  public:
+    flatten_iterator_layer() = default;
+    flatten_iterator_layer(layer v) : layer(v), next_layer() {
+      if ( !v.done() ) {
+        next_layer::assign({ std::begin(v->second), std::end(v->second) });
+      }
+    }
+    
+    reference operator*() {
+      return std::tuple_cat(std::forward_as_tuple(layer::operator*().first), next_layer::operator*());
+    }
+    
+    pointer operator->();
+    //    pointer operator->() {
+    //      return next_layer::operator->();
+    //    }
+    
+    bool operator==(flatten_iterator_layer const & other) const {
+      return layer::operator==(other) && next_layer::operator==(other);
+    }
+  protected:
+    void next() {
+      layer & self = static_cast<layer&>(*this);
+      next_layer::next();
+      while ( next_layer::done() && !(++self).done() ) {
+        next_layer::assign({ std::begin(self->second), std::end(self->second) });
+      }
+    }
+    
+    void assign(layer eat) {
+      static_cast<layer&>(*this) = eat;
+    }
+    
+    bool done() const { return layer::done(); }
+  };
+  
   template <typename Iterator, std::size_t N, std::size_t Max, typename = void>
   class bounded_recursive_iterator_impl :
   public recursive_iterator_terminal< Iterator > {
@@ -135,18 +196,32 @@ namespace detail {
   public:
     using super::super;
   };
+  
+  template <typename Iterator, std::size_t N, std::size_t Max>
+  class bounded_recursive_iterator_impl< Iterator, N, Max, typename std::enable_if<N < Max, typename void_t<mapped_iterator<Iterator>>::type>::type > :
+  public flatten_iterator_layer< Iterator , bounded_recursive_iterator_impl< mapped_iterator<Iterator>, N+1, Max > > {
+  private:
+    using next_layer = bounded_recursive_iterator_impl< mapped_iterator<Iterator>, N+1, Max >;
+    using super = flatten_iterator_layer< Iterator, next_layer >;
+  public:
+    using super::super;
+  };
+  
+  template <typename Iterator>
+  class recursive_iterator_impl< Iterator, typename void_t<mapped_iterator<Iterator>>::type > :
+  public flatten_iterator_layer< Iterator, recursive_iterator_impl< mapped_iterator<Iterator> > > {
+  private:
+    using next_layer = recursive_iterator_impl< mapped_iterator<Iterator> >;
+    using super = flatten_iterator_layer< Iterator, next_layer >;
+  public:
+    using super::super;
+  };
 }
 
 template <typename Iterator>
-class recursive_iterator : detail::recursive_iterator_impl< Iterator > {
+class recursive_iterator : public detail::recursive_iterator_impl< Iterator > {
 private:
   using super = detail::recursive_iterator_impl< Iterator >;
-public:
-  using value_type = typename super::value_type;
-  using reference = typename super::reference;
-  using pointer = typename super::pointer;
-  using difference_type = typename super::difference_type;
-  using iterator_category = typename super::iterator_category;
 public:
   using super::super;
   
@@ -161,22 +236,13 @@ public:
     return tmp;
   }
   
-  using super::operator*;
-  using super::operator->;
-  using super::operator==;
   bool operator!=(recursive_iterator const & other) { return !(operator==(other)); }
 };
 
 template <typename Iterator, std::size_t N>
-class recursive_iterator_n : detail::bounded_recursive_iterator_impl< Iterator, 1, N > {
+class recursive_iterator_n : public detail::bounded_recursive_iterator_impl< Iterator, 1, N > {
 private:
   using super = detail::bounded_recursive_iterator_impl< Iterator, 1, N >;
-public:
-  using value_type = typename super::value_type;
-  using reference = typename super::reference;
-  using pointer = typename super::pointer;
-  using difference_type = typename super::difference_type;
-  using iterator_category = typename super::iterator_category;
 public:
   using super::super;
   
@@ -191,9 +257,6 @@ public:
     return tmp;
   }
   
-  using super::operator*;
-  using super::operator->;
-  using super::operator==;
   bool operator!=(recursive_iterator_n const & other) { return !(operator==(other)); }
 };
 }