[ADT] Add pointer_iterator, the opposite of pointee_iterator

[dblaikie]

include/llvm/ADT/iterator.h

269 ↗

(On Diff #68647)

This would make a non-conforming iterator (perhaps we should have a static_assert for this in iterator_adapter_base, if possible) - because you should be able to take references and pointers to op* and get the same thing back the next time you call op*, etc.

So, at least in theory/to be conforming, the iterator would need a pointer member that it initializes in op* (or op++/ctor) and returns a reference to that.

What do you think? Do we already have enough non-conforming iterators that this technicality isn't worth worrying about? Or is the extra contortion worthwhile? Is there a nice way to do it? (I suppose you have to do it in op*, because you don't know if the iterator is valid any other time so you can't pre-emptively initialize the pointer member)

[timshen]

Locally cache the pointer, so that we can return a reference from operator*().

llvm/trunk/include/llvm/ADT/iterator.h

struct pointee_iterator
   pointee_iterator() = default;
   template <typename U>
   pointee_iterator(U &&u)
       : pointee_iterator::iterator_adaptor_base(std::forward<U &&>(u)) {}
 
   T &operator*() const { return **this->I; }
 };
 
+template <typename WrappedIteratorT,
+          typename T = decltype(&*std::declval<WrappedIteratorT>())>
+class pointer_iterator
+    : public iterator_adaptor_base<pointer_iterator<WrappedIteratorT>,
+                                   WrappedIteratorT, T> {
+  mutable T Ptr;
+
+public:
+  pointer_iterator() {}
+
+  explicit pointer_iterator(WrappedIteratorT u)
+      : pointer_iterator::iterator_adaptor_base(std::move(u)) {}
+
+  T &operator*() { return Ptr = &*this->I; }
+  const T &operator*() const { return Ptr = &*this->I; }
+};
+
 }
 
 #endif

llvm/trunk/unittests/Support/IteratorTest.cpp

TEST(FilterIteratorTest, InputIterator) {
   int A[] = {0, 1, 2, 3, 4, 5, 6};
   auto Range = make_filter_range(
       make_range(InputIterator(std::begin(A)), InputIterator(std::end(A))),
       IsOdd);
   SmallVector<int, 3> Actual(Range.begin(), Range.end());
   EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual);
 }
 
+TEST(PointerIterator, Basic) {
+  int A[] = {1, 2, 3, 4};
+  pointer_iterator<int *> Begin(std::begin(A)), End(std::end(A));
+  EXPECT_EQ(A, *Begin);
+  ++Begin;
+  EXPECT_EQ(A + 1, *Begin);
+  ++Begin;
+  EXPECT_EQ(A + 2, *Begin);
+  ++Begin;
+  EXPECT_EQ(A + 3, *Begin);
+  ++Begin;
+  EXPECT_EQ(Begin, End);
+}
+
+TEST(PointerIterator, Const) {
+  int A[] = {1, 2, 3, 4};
+  const pointer_iterator<int *> Begin(std::begin(A));
+  EXPECT_EQ(A, *Begin);
+  EXPECT_EQ(A + 1, std::next(*Begin, 1));
+  EXPECT_EQ(A + 2, std::next(*Begin, 2));
+  EXPECT_EQ(A + 3, std::next(*Begin, 3));
+  EXPECT_EQ(A + 4, std::next(*Begin, 4));
+}
+
 } // anonymous namespace