Propagate DoubleEndedIterator through chained iterators

Author: danakj

subspace/containers/__private/slice_iter.h

@@ -107,6 +107,7 @@ struct [[sus_trivial_abi]] SliceIterMut final
     return SliceIterMut(start, len);
   }
 
+  // sus::iter::Iterator trait.
   Option<Item> next() noexcept final {
     if (ptr_ == end_) [[unlikely]]
       return Option<Item>::none();

subspace/containers/__private/vec_iter.h

@@ -39,6 +39,7 @@ struct VecIntoIter final
     return VecIntoIter(::sus::move(vec));
   }
 
+  // sus::iter::Iterator trait.
   Option<Item> next() noexcept final {
     if (front_index_ == back_index_) [[unlikely]]
       return Option<Item>::none();

subspace/iter/__private/adaptors.h

@@ -20,25 +20,24 @@
 namespace sus::iter::__private {
 
 /// An adaptor for range-based for loops.
-template <class Iterator>
+template <class Iter>
 class IteratorLoop final {
-  using Item = typename std::remove_reference_t<Iterator>::Item;
+  using Item = typename std::remove_reference_t<Iter>::Item;
 
  public:
-  IteratorLoop(Iterator iter) noexcept
-      : iter_(static_cast<Iterator&&>(iter)), item_(iter_.next()) {}
+  IteratorLoop(Iter&& iter) noexcept
+      : iter_(::sus::forward<Iter>(iter)), item_(iter_.next()) {}
 
   inline bool operator==(const __private::IteratorEnd&) const noexcept {
-    return item_.is_nome();
-  }
-  inline bool operator!=(const __private::IteratorEnd&) const noexcept {
-    return item_.is_some();
+    return item_.is_none();
   }
   inline void operator++() & noexcept { item_ = iter_.next(); }
-  inline Item operator*() & noexcept { return item_.take().unwrap(); }
+  inline Item operator*() & noexcept {
+    return item_.take().unwrap_unchecked(::sus::marker::unsafe_fn);
+  }
 
  private:
-  /* TODO: NonNull<IteratorBase<Item>> */ Iterator iter_;
+  Iter iter_;
   Option<Item> item_;
 };
 

subspace/iter/__private/iterator_loop.h

@@ -34,51 +34,92 @@ class IteratorImpl;
 ///
 /// BoxedIterator is only constructible from an iterator that is not trivially
 /// relocatable.
-template <class ItemT, size_t SubclassSize, size_t SubclassAlign>
+template <class ItemT, size_t SubclassSize, size_t SubclassAlign,
+          bool DoubleEnded>
 class [[sus_trivial_abi]] BoxedIterator final
-    : public IteratorImpl<BoxedIterator<ItemT, SubclassSize, SubclassAlign>,
-                          ItemT> {
+    : public IteratorImpl<
+          BoxedIterator<ItemT, SubclassSize, SubclassAlign, DoubleEnded>,
+          ItemT> {
  public:
   using Item = ItemT;
 
-  template <::sus::mem::Move IteratorSubclass>
-  static BoxedIterator with(IteratorSubclass&& subclass) noexcept
-    requires(::sus::convert::SameOrSubclassOf<
-                 IteratorSubclass*, IteratorImpl<IteratorSubclass, ItemT>*> &&
-             !::sus::mem::relocate_by_memcpy<IteratorSubclass>)
+  template <::sus::mem::Move Iter>
+  static BoxedIterator with(Iter&& iter) noexcept
+    requires(
+        ::sus::convert::SameOrSubclassOf<Iter*, IteratorImpl<Iter, Item>*> &&
+        !::sus::mem::relocate_by_memcpy<Iter>)
   {
-    return BoxedIterator(
-        *new IteratorSubclass(::sus::move(subclass)),  // Move it to the heap.
-        [](IteratorBase<Item>& iter) {
-          delete static_cast<IteratorSubclass*>(&iter);
-        });
+    // IteratorImpl also checks this. It's needed for correctness of the move
+    // onto the heap.
+    static_assert(std::is_final_v<Iter>);
+
+    if constexpr (DoubleEnded) {
+      return BoxedIterator(
+          new Iter(::sus::move(iter)),  // Move it to the heap.
+          [](void* boxed_iter) { delete static_cast<Iter*>(boxed_iter); },
+          [](void* boxed_iter) {
+            return static_cast<Iter*>(boxed_iter)->next();
+          },
+          [](void* boxed_iter) {
+            return static_cast<Iter*>(boxed_iter)->next_back();
+          });
+    } else {
+      return BoxedIterator(
+          new Iter(::sus::move(iter)),  // Move it to the heap.
+          [](void* boxed_iter) { delete static_cast<Iter*>(boxed_iter); },
+          [](void* boxed_iter) {
+            return static_cast<Iter*>(boxed_iter)->next();
+          });
+    }
   }
 
   BoxedIterator(BoxedIterator&& o) noexcept
       : iter_(::sus::mem::replace_ptr(mref(o.iter_), nullptr)),
-        destroy_(::sus::mem::replace_ptr(mref(o.destroy_), nullptr)) {}
+        destroy_(::sus::mem::replace_ptr(mref(o.destroy_), nullptr)),
+        next_(::sus::mem::replace_ptr(mref(o.next_), nullptr)),
+        next_back_(::sus::mem::replace_ptr(mref(o.next_back_), nullptr)) {}
   BoxedIterator& operator=(BoxedIterator&& o) noexcept {
-    if (destroy_) destroy_(*iter_);
+    if (destroy_) destroy_(iter_);
     iter_ = ::sus::mem::replace_ptr(mref(o.iter_), nullptr);
     destroy_ = ::sus::mem::replace_ptr(mref(o.destroy_), nullptr);
+    next_ = ::sus::mem::replace_ptr(mref(o.next_), nullptr);
+    next_back_ = ::sus::mem::replace_ptr(mref(o.next_back_), nullptr);
   }
 
   ~BoxedIterator() {
-    if (destroy_) destroy_(*iter_);
+    if (destroy_) destroy_(iter_);
   }
 
-  Option<Item> next() noexcept final { return iter_->next(); }
+  // sus::iter::Iterator trait.
+  Option<Item> next() noexcept final { return next_(iter_); }
+  // sus::iter::DoubleEndedIterator trait.
+  Option<Item> next_back() noexcept
+    requires(DoubleEnded)
+  {
+    return next_back_(iter_);
+  }
 
  private:
-  BoxedIterator(IteratorBase<Item>& iter,
-                void (*destroy)(IteratorBase<Item>& boxed))
-      : iter_(&iter), destroy_(destroy) {}
+  // DoubleEnded constructor.
+  BoxedIterator(void* iter, void (*destroy)(void* boxed_iter),
+                Option<Item> (*next)(void* boxed_iter),
+                Option<Item> (*next_back)(void* boxed_iter))
+      : iter_(iter), destroy_(destroy), next_(next), next_back_(next_back) {}
+  // Not-DoubleEnded constructor.
+  BoxedIterator(void* iter, void (*destroy)(void* boxed_iter),
+                Option<Item> (*next)(void* boxed_iter))
+      : iter_(iter), destroy_(destroy), next_(next), next_back_(nullptr) {}
 
-  IteratorBase<Item>* iter_;
-  void (*destroy_)(IteratorBase<Item>& boxed);
+  void* iter_;
+  void (*destroy_)(void* boxed_iter);
+  Option<Item> (*next_)(void* boxed_iter);
+  // TODO: We could remove this field with a nested struct + template
+  // specialization when DoubleEnded is false.
+  Option<Item> (*next_back_)(void* boxed_iter);
 
   sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(iter_),
-                                  decltype(destroy_));
+                                  decltype(destroy_), decltype(next_),
+                                  decltype(next_back_));
 };
 
 }  // namespace sus::iter

subspace/iter/boxed_iterator.h

@@ -28,9 +28,12 @@ class [[sus_trivial_abi]] Empty final
 
   constexpr Empty() = default;
 
+  // sus::iter::Iterator trait.
   constexpr Option<Item> next() noexcept final {
     return sus::Option<Item>::none();
   }
+  // sus::iter::DoubleEndedIterator trait.
+  Option<Item> next_back() noexcept { return sus::Option<Item>::none(); }
 
  private:
   sus_class_trivially_relocatable(::sus::marker::unsafe_fn);

subspace/iter/empty.h

@@ -24,28 +24,45 @@ namespace sus::iter {
 
 using ::sus::mem::relocate_by_memcpy;
 
-template <class ItemT, size_t InnerIterSize, size_t InnerIterAlign>
-class Filter final
-    : public IteratorImpl<Filter<ItemT, InnerIterSize, InnerIterAlign>, ItemT> {
+template <class InnerSizedIter>
+class [[sus_trivial_abi]] Filter final
+    : public IteratorImpl<Filter<InnerSizedIter>,
+                          typename InnerSizedIter::Item> {
   using Pred = ::sus::fn::FnMut<bool(
       // TODO: write a sus::const_ref<T>?
-      const std::remove_reference_t<const std::remove_reference_t<ItemT>&>&)>;
-  using InnerSizedIter = SizedIterator<ItemT, InnerIterSize, InnerIterAlign>;
+      const std::remove_reference_t<typename InnerSizedIter::Item>&)>;
 
  public:
-  using Item = ItemT;
+  using Item = InnerSizedIter::Item;
 
   static Filter with(Pred&& pred, InnerSizedIter&& next_iter) noexcept {
     return Filter(::sus::move(pred), ::sus::move(next_iter));
   }
 
+  // sus::iter::Iterator trait.
   Option<Item> next() noexcept final {
-    IteratorBase<Item>& next_iter = next_iter_.iterator_mut();
+    InnerSizedIter& iter = next_iter_;
     Pred& pred = pred_;
 
     // TODO: Just call find(pred) on itself?
     while (true) {
-      Option<Item> item = next_iter.next();
+      Option<Item> item = iter.next();
+      if (item.is_none() ||
+          pred(item.as_ref().unwrap_unchecked(::sus::marker::unsafe_fn)))
+        return item;
+    }
+  }
+
+  // sus::iter::DoubleEndedIterator trait.
+  Option<Item> next_back() noexcept
+    requires(InnerSizedIter::DoubleEnded)
+  {
+    InnerSizedIter& iter = next_iter_;
+    Pred& pred = pred_;
+
+    // TODO: Just call find(pred) on itself?
+    while (true) {
+      Option<Item> item = iter.next_back();
       if (item.is_none() ||
           pred(item.as_ref().unwrap_unchecked(::sus::marker::unsafe_fn)))
         return item;

subspace/iter/filter.h

@@ -19,7 +19,11 @@
 
 #include "subspace/convert/subclass.h"
 #include "subspace/mem/forward.h"
-#include "subspace/option/option.h"
+
+namespace sus::option {
+template <class T>
+class Option;
+}
 
 namespace sus::iter {
 
@@ -28,7 +32,7 @@ class IteratorImpl;
 
 /// A concept for all implementations of iterators.
 ///
-/// An iterator has a method, `next()`, which when called, returns an
+/// An iterator has one required method, `next()`, which when called, returns an
 /// `Option<Item>`. Calling next will return an `Option` containing the next
 /// `Item` as long as there are elements, and once they've all been exhausted,
 /// will return `None` to indicate that iteration is finished. Individual
@@ -45,14 +49,16 @@ class IteratorImpl;
 /// Iterators are also composable, and it's possible to chain them together to
 /// do more complex forms of processing.
 template <class T, class Item>
-concept Iterator = requires {
+concept Iterator = requires(T& t) {
   // Has a T::Item typename.
   requires(!std::is_void_v<typename std::decay_t<T>::Item>);
   // The T::Item matches the concept input.
   requires(std::same_as<typename std::decay_t<T>::Item, Item>);
   // Subclasses from IteratorImpl<T, T::Item>.
   requires ::sus::convert::SameOrSubclassOf<
       std::decay_t<T>*, IteratorImpl<std::decay_t<T>, Item>*>;
+  // Required methods.
+  { t.next() } -> std::same_as<::sus::option::Option<Item>>;
 };
 
 /// An `Iterator` able to yield elements from both ends.