Function longest_wrapping_true_run

src/svgfill/src/arrange_polygons.cpp:2608–2669

template <typename Vec, typename Pred>
std::pair<typename Vec::const_iterator,
          typename Vec::const_iterator>
longest_wrapping_true_run(const Vec& v, Pred pred) {
    using It = typename Vec::const_iterator;

    const auto n = v.size();
    if (n == 0) {
        return {v.end(), v.end()};
    }

    // Find best non-wrapping run
    std::size_t best_len = 0;
    std::size_t best_start = 0;

    std::size_t curr_len = 0;
    std::size_t curr_start = 0;

    for (std::size_t i = 0; i < n; ++i) {
        if (pred(v[i])) {
            if (curr_len == 0) {
                curr_start = i;
            }
            ++curr_len;
            if (curr_len > best_len) {
                best_len = curr_len;
                best_start = curr_start;
            }
        } else {
            curr_len = 0;
        }
    }

    // Count leading true
    std::size_t leading = 0;
    while (leading < n && pred(v[leading])) {
        ++leading;
    }

    // All true
    if (leading == n) {
        return {v.begin(), v.end()};
    }

    // Count trailing true
    std::size_t trailing = 0;
    while (trailing < n && pred(v[n - 1 - trailing])) {
        ++trailing;
    }

    // Wrapped run = [n - trailing, n) + [0, leading)
    const std::size_t wrapped_len = leading + trailing;

    if (wrapped_len > best_len) {
        It first = v.begin() + static_cast<std::ptrdiff_t>(n - trailing);
        It last = v.begin() + static_cast<std::ptrdiff_t>(leading);
        return {first, last};
    }