discard

fn discard(io_reader: *std.Io.Reader, limit: std.Io.Limit) std.Io.Reader.Error!usize {
    const r: *Reader = @alignCast(@fieldParentPtr("interface", io_reader));
    const file = r.file;
    const pos = r.pos;
    switch (r.mode) {
        .positional, .positional_reading => {
            const size = r.getSize() catch {
                r.mode = r.mode.toStreaming();
                return 0;
            };
            const delta = @min(@intFromEnum(limit), size - pos);
            r.pos = pos + delta;
            return delta;
        },
        .streaming, .streaming_reading => {
            // Unfortunately we can't seek forward without knowing the
            // size because the seek syscalls provided to us will not
            // return the true end position if a seek would exceed the
            // end.
            fallback: {
                if (r.size_err == null and r.seek_err == null) break :fallback;
                var trash_buffer: [128]u8 = undefined;
                if (is_windows) {
                    const n = windows.ReadFile(file.handle, limit.slice(&trash_buffer), null) catch |err| {
                        r.err = err;
                        return error.ReadFailed;
                    };
                    if (n == 0) {
                        r.size = pos;
                        return error.EndOfStream;
                    }
                    r.pos = pos + n;
                    return n;
                }
                var iovecs: [max_buffers_len]std.posix.iovec = undefined;
                var iovecs_i: usize = 0;
                var remaining = @intFromEnum(limit);
                while (remaining > 0 and iovecs_i < iovecs.len) {
                    iovecs[iovecs_i] = .{ .base = &trash_buffer, .len = @min(trash_buffer.len, remaining) };
                    remaining -= iovecs[iovecs_i].len;
                    iovecs_i += 1;
                }
                const n = posix.readv(file.handle, iovecs[0..iovecs_i]) catch |err| {
                    r.err = err;
                    return error.ReadFailed;
                };
                if (n == 0) {
                    r.size = pos;
                    return error.EndOfStream;
                }
                r.pos = pos + n;
                return n;
            }
            const size = r.getSize() catch return 0;
            const n = @min(size - pos, maxInt(i64), @intFromEnum(limit));
            file.seekBy(n) catch |err| {
                r.seek_err = err;
                return 0;
            };
            r.pos = pos + n;
            return n;
        },
        .failure => return error.ReadFailed,
    }
}