Class iterator

include/stringzilla/stringzilla.hpp:779–838

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

    class iterator {
        char const *start_;      // Start of current segment
        char const *end_;        // End of haystack (immutable)
        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 ? position : haystack.size();
        }

        iterator(string_view_type haystack, matcher_type matcher, end_sentinel_type) noexcept
            : start_(haystack.data() + haystack.size() + 1), end_(haystack.data() + haystack.size()), match_length_(0),
              matcher_(matcher) {}

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

        iterator &operator++() noexcept {
            start_ += match_length_;
            if (start_ > end_) return *this;
            // If we were at the end (yielded final empty segment), move past to terminate
            if (start_ == end_) {
                ++start_;
                match_length_ = 0;
                return *this;
            }
            // Skip delimiter
            start_ += matcher_.needle_length();
            if (start_ > end_) {
                match_length_ = 0;
                return *this;
            }
            // Find next delimiter
            string_view_type remaining(start_, static_cast<size_type>(end_ - start_));
            auto position = matcher_(remaining);
            match_length_ = position != string_type::npos ? position : remaining.size();
            return *this;
        }

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

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