Improve accessor test quality.

Temporarily disable in_place ctor/tests

include/iterator/recursive_iterator.hpp

@@ -144,12 +144,13 @@ namespace iterator { namespace detail {
     recursive_iterator_layer(recursive_iterator_layer<OIter, Rec> const & other)
         : layer(static_cast<recursive_iterator_base<OIter> const &>(other)),
           super(static_cast<Rec const &>(other)) {}
-    template <typename OIter, typename... Iterators>
-    recursive_iterator_layer(in_place_t, OIter && it, Iterators &&... iter)
-        : layer(std::forward<OIter>(it)),
-          super(in_place, std::forward<Iterators>(iter)...) {
-      update();
-    }
+    //    template <typename OIter, typename... Iterators>
+    //    recursive_iterator_layer(in_place_t, OIter && it, Iterators &&...
+    //    iter)
+    //        : layer(std::forward<OIter>(it)),
+    //          super(in_place, std::forward<Iterators>(iter)...) {
+    //      update();
+    //    }
 
     reference operator*() const { return super::get(); }
 
@@ -249,12 +250,12 @@ namespace iterator { namespace detail {
     flatten_iterator_layer(flatten_iterator_layer<OIter, Rec> const & other)
         : layer(static_cast<recursive_iterator_base<OIter> const &>(other)),
           super(static_cast<Rec const &>(other)) {}
-    template <typename OIter, typename... Iterators>
-    flatten_iterator_layer(in_place_t, OIter && it, Iterators &&... iter)
-        : layer(std::forward<OIter>(it)),
-          super(in_place, std::forward<Iterators>(iter)...) {
-      update();
-    }
+    //    template <typename OIter, typename... Iterators>
+    //    flatten_iterator_layer(in_place_t, OIter && it, Iterators &&... iter)
+    //        : layer(std::forward<OIter>(it)),
+    //          super(in_place, std::forward<Iterators>(iter)...) {
+    //      update();
+    //    }
 
     /**
      * @brief Concatenate the key in this layer, with the dereferenced data from
@@ -335,9 +336,9 @@ namespace iterator {
   public:
     using super::super;
     recursive_iterator() = default;
-    template <typename... Iterators>
-    recursive_iterator(in_place_t, Iterators &&... iter)
-        : super(in_place, std::forward<Iterators>(iter)...) {}
+    //    template <typename... Iterators>
+    //    recursive_iterator(in_place_t, Iterators &&... iter)
+    //        : super(in_place, std::forward<Iterators>(iter)...) {}
 
     recursive_iterator & operator++() {
       (void)super::next();
@@ -350,7 +351,7 @@ namespace iterator {
       return tmp;
     }
 
-    bool operator!=(recursive_iterator const & other) {
+    bool operator!=(recursive_iterator const & other) const {
       return !(super::operator==(other));
     }
   };
@@ -382,9 +383,9 @@ namespace iterator {
   public:
     using super::super;
     recursive_iterator_n() = default;
-    template <typename... Iterators>
-    recursive_iterator_n(in_place_t, Iterators &&... iter)
-        : super(in_place, std::forward<Iterators>(iter)...) {}
+    //    template <typename... Iterators>
+    //    recursive_iterator_n(in_place_t, Iterators &&... iter)
+    //        : super(in_place, std::forward<Iterators>(iter)...) {}
 
     recursive_iterator_n & operator++() {
       (void)super::next();
@@ -397,7 +398,7 @@ namespace iterator {
       return tmp;
     }
 
-    bool operator!=(recursive_iterator_n const & other) {
+    bool operator!=(recursive_iterator_n const & other) const {
       return !(super::operator==(other));
     }
   };
@@ -410,15 +411,23 @@ namespace std {
           I, ::iterator::recursive_iterator<It>>::type {
     return iter;
   }
-}
 
-template <typename Iter0, typename... Iters>
-auto make_recursive_iterator(iterator::end_aware_iterator<Iter0> it,
-                             Iters &&... iters)
-    -> iterator::recursive_iterator<Iter0> {
-  return {iterator::in_place, std::move(it), std::forward<Iters>(iters)...};
+  template <std::size_t I, typename It, std::size_t N>
+  auto get(::iterator::recursive_iterator_n<It, N> const & iter) ->
+      typename ::iterator::detail::accessor<
+          I, ::iterator::recursive_iterator_n<It, N>>::type {
+    static_assert(I < N, "Cannot get past bounding level");
+    return iter;
+  }
 }
 
+// template <typename Iter0, typename... Iters>
+// auto make_recursive_iterator(iterator::end_aware_iterator<Iter0> it,
+//                             Iters &&... iters)
+//    -> iterator::recursive_iterator<Iter0> {
+//  return {iterator::in_place, std::move(it), std::forward<Iters>(iters)...};
+//}
+
 template <typename C>
 auto make_recursive_iterator(C & collect)
     -> iterator::recursive_iterator<decltype(std::begin(collect))> {

include/iterator/recursive_iterator_meta.hpp

@@ -26,9 +26,9 @@ namespace iterator { namespace detail {
   public:
     using super::super;
     recursive_iterator_impl() = default;
-    template <typename OIter>
-    recursive_iterator_impl(in_place_t, OIter && iter)
-        : super(std::forward<OIter>(iter)) {}
+    //    template <typename OIter>
+    //    recursive_iterator_impl(in_place_t, OIter && iter)
+    //        : super(std::forward<OIter>(iter)) {}
 
   protected:
     void next() { super::operator++(); }
@@ -63,9 +63,9 @@ namespace iterator { namespace detail {
     }
     using super::super;
     recursive_iterator_impl() = default;
-    template <typename... Iterators>
-    recursive_iterator_impl(in_place_t, Iterators &&... iter)
-        : super(in_place, std::forward<Iterators>(iter)...) {}
+    //    template <typename... Iterators>
+    //    recursive_iterator_impl(in_place_t, Iterators &&... iter)
+    //        : super(in_place, std::forward<Iterators>(iter)...) {}
   };
 
   /**
@@ -87,9 +87,9 @@ namespace iterator { namespace detail {
   public:
     using super::super;
     recursive_iterator_impl() = default;
-    template <typename... Iterators>
-    recursive_iterator_impl(in_place_t, Iterators &&... iter)
-        : super(in_place, std::forward<Iterators>(iter)...) {}
+    //    template <typename... Iterators>
+    //    recursive_iterator_impl(in_place_t, Iterators &&... iter)
+    //        : super(in_place, std::forward<Iterators>(iter)...) {}
   };
 
   /**
@@ -113,9 +113,9 @@ namespace iterator { namespace detail {
   public:
     using super::super;
     bounded_recursive_iterator_impl() = default;
-    template <typename OIter>
-    bounded_recursive_iterator_impl(in_place_t, OIter && iter)
-        : super(std::forward<OIter>(iter)) {}
+    //    template <typename OIter>
+    //    bounded_recursive_iterator_impl(in_place_t, OIter && iter)
+    //        : super(std::forward<OIter>(iter)) {}
 
   protected:
     void next() { super::operator++(); }
@@ -154,9 +154,9 @@ namespace iterator { namespace detail {
     }
     using super::super;
     bounded_recursive_iterator_impl() = default;
-    template <typename... Iterators>
-    bounded_recursive_iterator_impl(in_place_t, Iterators &&... iter)
-        : super(in_place, std::forward<Iterators>(iter)...) {}
+    //    template <typename... Iterators>
+    //    bounded_recursive_iterator_impl(in_place_t, Iterators &&... iter)
+    //        : super(in_place, std::forward<Iterators>(iter)...) {}
   };
 
   /**
@@ -182,9 +182,9 @@ namespace iterator { namespace detail {
   public:
     using super::super;
     bounded_recursive_iterator_impl() = default;
-    template <typename... Iterators>
-    bounded_recursive_iterator_impl(in_place_t, Iterators &&... iter)
-        : super(in_place, std::forward<Iterators>(iter)...) {}
+    //    template <typename... Iterators>
+    //    bounded_recursive_iterator_impl(in_place_t, Iterators &&... iter)
+    //        : super(in_place, std::forward<Iterators>(iter)...) {}
   };
 }}
 

test/recursive_iterator_accessors_test.cxx

@@ -11,11 +11,9 @@ TEST(RecursiveIteratorTest, CanStdGetToAllLayersOfInternalIteration) {
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
   auto rit = make_recursive_iterator(obj);
-  EXPECT_TRUE(
-      (testing::StaticAssertTypeEq<
-          decltype(std::get<0>(rit)),
-          iterator::end_aware_iterator<
-              std::map<int, std::vector<std::map<int, int>>>::iterator>>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<
+               decltype(std::get<0>(rit)),
+               iterator::end_aware_iterator<decltype(obj)::iterator>>()));
   EXPECT_TRUE(
       (testing::StaticAssertTypeEq<decltype(std::get<1>(rit)),
                                    iterator::end_aware_iterator<std::vector<
@@ -23,28 +21,113 @@ TEST(RecursiveIteratorTest, CanStdGetToAllLayersOfInternalIteration) {
   EXPECT_TRUE((testing::StaticAssertTypeEq<
                decltype(std::get<2>(rit)),
                iterator::end_aware_iterator<std::map<int, int>::iterator>>()));
+  EXPECT_TRUE((testing::StaticAssertTypeEq<
+               decltype(*rit), std::tuple<int const &, int const &, int &>>()));
+}
+
+TEST(RecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
+  std::map<int, std::vector<std::map<int, int>>> obj{
+      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
+      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
+  };
+  auto rit = make_recursive_iterator(obj);
+  EXPECT_THAT(std::get<0>(rit), make_end_aware_iterator(obj));
+  EXPECT_THAT(std::get<1>(rit), make_end_aware_iterator(obj[1]));
+  EXPECT_THAT(std::get<2>(rit), make_end_aware_iterator(obj[1][0]));
+}
+
+// TODO: This ought to be implemented as a compiles-test
+TEST(RecursiveIteratorTest, CanCastCompatibleIterators) {
+  std::map<int, std::vector<std::map<int, int>>> obj{
+      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
+      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
+  };
+  auto rit = make_recursive_iterator(obj);
+  iterator::recursive_iterator<decltype(obj)::const_iterator> cit(rit);
 }
 
-TEST(RecursiveIteratorTest, CanConstructInPlaceFromIterators) {
-  std::map<int, std::vector<std::map<int, int>>> const obj{
-      {1, {{{1, 1}}, {{2, 2}}}}, {2, {{{3, 3}, {4, 4}}}}};
-  auto const it = make_end_aware_iterator(obj.begin(), obj.end());
-  auto const it_1 = ++make_end_aware_iterator(it->second);
-  auto const it_2 = make_end_aware_iterator(*it_1);
-  // Note that this carries the weakness of non bounds-checking that our
-  // iterators are all sitting on the same hierarchy...
-  EXPECT_NO_THROW(make_recursive_iterator(it, it_1, it_2));
-}
-
-TEST(RecursiveIteratorTest, InternalIteratorsFromStdGetMatchCtorArgs) {
-  std::map<int, std::vector<std::map<int, int>>> const obj{
-      {1, {{{1, 1}}, {{2, 2}}}}, {2, {{{3, 3}, {4, 4}}}}};
-  auto const it = make_end_aware_iterator(obj.begin(), obj.end());
-  auto const it_1 = ++make_end_aware_iterator(it->second);
-  auto const it_2 = make_end_aware_iterator(*it_1);
-  iterator::recursive_iterator<decltype(obj.cbegin())> rit{iterator::in_place,
-                                                           it, it_1, it_2};
-  EXPECT_THAT(std::get<0>(rit), it);
-  EXPECT_THAT(std::get<1>(rit), it_1);
-  EXPECT_THAT(std::get<2>(rit), it_2);
+TEST(RecursiveIteratorTest, EmptyCtorIsEnd) {
+  std::map<int, std::vector<std::map<int, int>>> obj{
+      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
+      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
+  };
+  auto rit = make_recursive_iterator(obj);
+  EXPECT_THAT(rit, testing::Ne(decltype(rit)()));
+  EXPECT_THAT(std::distance(rit, decltype(rit)()), 4);
+  std::advance(rit, 4);
+  EXPECT_THAT(rit, decltype(rit)());
 }
+
+TEST(BoundedRecursiveIteratorTest, CanStdGetToNLayersOfInternalIteration) {
+  std::map<int, std::vector<std::map<int, int>>> obj{
+      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
+      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
+  };
+  auto rit = make_recursive_iterator<2>(obj);
+  EXPECT_TRUE((testing::StaticAssertTypeEq<
+               decltype(std::get<0>(rit)),
+               iterator::end_aware_iterator<decltype(obj)::iterator>>()));
+  EXPECT_TRUE(
+      (testing::StaticAssertTypeEq<decltype(std::get<1>(rit)),
+                                   iterator::end_aware_iterator<std::vector<
+                                       std::map<int, int>>::iterator>>()));
+  EXPECT_TRUE(
+      (testing::StaticAssertTypeEq<
+          decltype(*rit), std::tuple<int const &, std::map<int, int> &>>()));
+}
+
+TEST(BoundedRecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
+  std::map<int, std::vector<std::map<int, int>>> obj{
+      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
+      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
+  };
+  auto rit = make_recursive_iterator<2>(obj);
+  EXPECT_THAT(std::get<0>(rit), make_end_aware_iterator(obj));
+  EXPECT_THAT(std::get<1>(rit), make_end_aware_iterator(obj[1]));
+}
+
+// TODO: This ought to be implemented as a compiles-test
+TEST(BoundedRecursiveIteratorTest, CanCastCompatibleIterators) {
+  std::map<int, std::vector<std::map<int, int>>> obj{
+      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
+      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
+  };
+  auto rit = make_recursive_iterator<2>(obj);
+  iterator::recursive_iterator_n<decltype(obj)::const_iterator, 2> cit(rit);
+}
+
+TEST(BoundedRecursiveIteratorTest, EmptyCtorIsEnd) {
+  std::map<int, std::vector<std::map<int, int>>> obj{
+      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
+      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
+  };
+  auto rit = make_recursive_iterator<2>(obj);
+  EXPECT_THAT(rit, testing::Ne(decltype(rit)()));
+  EXPECT_THAT(std::distance(rit, decltype(rit)()), 3);
+  std::advance(rit, 3);
+  EXPECT_THAT(rit, decltype(rit)());
+}
+
+// TEST(RecursiveIteratorTest, CanConstructInPlaceFromIterators) {
+//  std::map<int, std::vector<std::map<int, int>>> const obj{
+//      {1, {{{1, 1}}, {{2, 2}}}}, {2, {{{3, 3}, {4, 4}}}}};
+//  auto const it = make_end_aware_iterator(obj.begin(), obj.end());
+//  auto const it_1 = ++make_end_aware_iterator(it->second);
+//  auto const it_2 = make_end_aware_iterator(*it_1);
+//  // Note that this carries the weakness of non bounds-checking that our
+//  // iterators are all sitting on the same hierarchy...
+//  EXPECT_NO_THROW(make_recursive_iterator(it, it_1, it_2));
+//}
+//
+// TEST(RecursiveIteratorTest, InternalIteratorsFromStdGetMatchCtorArgs) {
+//  std::map<int, std::vector<std::map<int, int>>> const obj{
+//      {1, {{{1, 1}}, {{2, 2}}}}, {2, {{{3, 3}, {4, 4}}}}};
+//  auto const it = make_end_aware_iterator(obj.begin(), obj.end());
+//  auto const it_1 = ++make_end_aware_iterator(it->second);
+//  auto const it_2 = make_end_aware_iterator(*it_1);
+//  iterator::recursive_iterator<decltype(obj.cbegin())> rit{iterator::in_place,
+//                                                           it, it_1, it_2};
+//  EXPECT_THAT(std::get<0>(rit), it);
+//  EXPECT_THAT(std::get<1>(rit), it_1);
+//  EXPECT_THAT(std::get<2>(rit), it_2);
+//}