Class iterator

include/stringzilla/stringzilla.hpp:896–956

    range_rsplits(string_type haystack, matcher_type needle) noexcept : matcher_(needle), haystack_(haystack) {}

    class iterator {
        char const *start_;      // Start of haystack (immutable)
        char const *end_;        // Current end position (moves backward)
        size_type match_length_; // Length of current segment
        matcher_type matcher_;

      public:
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = string_view_type;
        using pointer = string_view_type;   // Needed for compatibility with STL container constructors.
        using reference = string_view_type; // Needed for compatibility with STL container constructors.

        iterator(string_view_type haystack, matcher_type matcher) noexcept
            : start_(haystack.data()), end_(haystack.data() + haystack.size()), match_length_(0), matcher_(matcher) {
            auto position = matcher_(haystack);
            match_length_ =
                position != string_type::npos ? haystack.size() - position - matcher_.needle_length() : haystack.size();
        }

        iterator(string_view_type, matcher_type matcher, end_sentinel_type) noexcept
            : start_(reinterpret_cast<char const *>(1)), end_(nullptr), match_length_(0), matcher_(matcher) {}

        pointer operator->() const noexcept = delete;
        value_type operator*() const noexcept { return string_view_type(end_ - match_length_, match_length_); }

        iterator &operator++() noexcept {
            end_ -= match_length_;
            if (end_ < start_) return *this;
            // If we were at the start (yielded final empty segment), signal termination
            if (end_ == start_) {
                end_ = nullptr;
                start_ = reinterpret_cast<char const *>(1);
                return *this;
            }
            // Skip delimiter
            end_ -= matcher_.needle_length();
            if (end_ < start_) {
                match_length_ = 0;
                return *this;
            }
            // Find next delimiter (searching backwards)
            string_view_type remaining(start_, static_cast<size_type>(end_ - start_));
            auto position = matcher_(remaining);
            match_length_ = position != string_type::npos ? remaining.size() - position - matcher_.needle_length()
                                                          : remaining.size();
            return *this;
        }

        iterator operator++(int) noexcept {
            iterator temp = *this;
            ++(*this);
            return temp;
        }

        bool operator!=(iterator const &other) const noexcept { return end_ != other.end_; }
        bool operator==(iterator const &other) const noexcept { return end_ == other.end_; }
        bool operator!=(end_sentinel_type) const noexcept { return end_ >= start_; }