Skip to content
Standard libraryZig 0.17.0Official documentation
Sourcestd/Io/Reader.zig

Source line 1

Fields

vtable: *const VTable
buffer: []u8
seek: usize

Number of bytes which have been consumed from buffer.

end: usize

In buffer before this are buffered bytes, after this is undefined.

std.Io.Reader.Allocator

alias

Source line 11

Alias of std.mem.Allocator

std.Io.Reader.allocRemaining

function

Source line 296

Transfers all bytes from the current position to the end of the stream, up to limit, returning them as a caller-owned allocated slice.

If limit is exceeded, error.StreamTooLong is returned instead. In such case, the next byte that would be read will be one byte past the first one to exceed limit, and all preceeding bytes have been discarded.

See also:

pub fn allocRemaining(r: *Reader, gpa: Allocator, limit: Limit) LimitedAllocError![]u8

Parameters

r: *Reader
gpa: Allocator
limit: Limit

Errors

OutOfMemory Error
ReadFailed ShortError

See the Reader implementation for detailed diagnostics.

StreamTooLong

Example usage

test allocRemaining {
    {
        var r: Reader = .fixed("abc");
        const str = try r.allocRemaining(testing.allocator, .unlimited);
        defer testing.allocator.free(str);
        try testing.expectEqualStrings("abc", str);
    }
    {
        var r: Reader = .fixed("abc");
        const str = try r.allocRemaining(testing.allocator, .limited(5));
        defer testing.allocator.free(str);
        try testing.expectEqualStrings("abc", str);
    }
    {
        var r: Reader = .fixed("abc");
        const str = try r.allocRemaining(testing.allocator, .limited(3));
        defer testing.allocator.free(str);
        try testing.expectEqualStrings("abc", str);
    }
    {
        var r: Reader = .fixed("abcd");
        try testing.expectError(error.StreamTooLong, r.allocRemaining(testing.allocator, .limited(3)));
    }
}

std.Io.Reader.allocRemainingAlignedSentinel

function

Source line 307

pub fn allocRemainingAlignedSentinel( r: *Reader, gpa: Allocator, limit: Limit, comptime alignment: std.mem.Alignment, comptime sentinel: ?u8, ) LimitedAllocError!(if (sentinel) |s| [:s]align(alignment.toByteUnits()) u8 else []align(alignment.toByteUnits()) u8)

Parameters

r: *Reader
gpa: Allocator
limit: Limit
alignment: std.mem.Alignment
sentinel: ?u8

Errors

OutOfMemory Error
ReadFailed ShortError

See the Reader implementation for detailed diagnostics.

StreamTooLong

std.Io.Reader.appendExact

function

Source line 330

Transfers exactly n bytes from the reader to the ArrayList.

See also:

pub fn appendExact( r: *Reader, gpa: Allocator, list: *ArrayList(u8), n: usize, ) AppendExactError!void

Parameters

r: *Reader
gpa: Allocator
list: *ArrayList(u8)
n: usize

Errors

EndOfStream Error
OutOfMemory Error
ReadFailed Error

See the Reader implementation for detailed diagnostics.

std.Io.Reader.AppendExactError

error-set

Source line 324

Errors

EndOfStream Error
OutOfMemory Error
ReadFailed Error

See the Reader implementation for detailed diagnostics.

std.Io.Reader.appendRemaining

function

Source line 355

Transfers all bytes from the current position to the end of the stream, up to limit, appending them to list.

If limit is reached or exceeded, error.StreamTooLong is returned instead. In such case, the next byte that would be read will be the first one to exceed limit, and all preceeding bytes have been appended to list.

See also:

pub fn appendRemaining( r: *Reader, gpa: Allocator, list: *ArrayList(u8), limit: Limit, ) LimitedAllocError!void

Parameters

r: *Reader
gpa: Allocator
list: *ArrayList(u8)
limit: Limit

Errors

OutOfMemory Error
ReadFailed ShortError

See the Reader implementation for detailed diagnostics.

StreamTooLong

std.Io.Reader.appendRemainingAligned

function

Source line 375

Transfers all bytes from the current position to the end of the stream, up to limit, appending them to list.

If limit is reached or exceeded, error.StreamTooLong is returned instead. In such case, the next byte that would be read will be the first one to exceed limit, and all preceeding bytes have been appended to list.

See also:

pub fn appendRemainingAligned( r: *Reader, gpa: Allocator, comptime alignment: std.mem.Alignment, list: *std.array_list.Aligned(u8, alignment), limit: Limit, ) LimitedAllocError!void

Parameters

r: *Reader
gpa: Allocator
alignment: std.mem.Alignment
list: *std.array_list.Aligned(u8, alignment)
limit: Limit

Errors

OutOfMemory Error
ReadFailed ShortError

See the Reader implementation for detailed diagnostics.

StreamTooLong

std.Io.Reader.appendRemainingUnlimited

function

Source line 399

pub fn appendRemainingUnlimited(r: *Reader, gpa: Allocator, list: *ArrayList(u8)) UnlimitedAllocError!void

Parameters

r: *Reader
gpa: Allocator
list: *ArrayList(u8)

Errors

OutOfMemory Error
ReadFailed ShortError

See the Reader implementation for detailed diagnostics.

std.Io.Reader.ArrayList

alias

Source line 12

Alias of std.ArrayList

std.Io.Reader.assert

alias

Source line 9

Alias of std.debug.assert

std.Io.Reader.buffered

function

Source line 478

pub fn buffered(r: *Reader) []u8

Parameters

r: *Reader

std.Io.Reader.bufferedLen

function

Source line 482

pub fn bufferedLen(r: *const Reader) usize

Parameters

r: *const Reader

std.Io.Reader.builtin

constant

Source line 3

std.Io.Reader.defaultDiscard

function

Source line 196

pub fn defaultDiscard(r: *Reader, limit: Limit) Error!usize

Parameters

r: *Reader
limit: Limit

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.defaultReadVec

function

Source line 450

Writes to Reader.buffer or data, whichever has larger capacity.

pub fn defaultReadVec(r: *Reader, data: [][]u8) Error!usize

Parameters

r: *Reader
data: [][]u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.defaultRebase

function

Source line 1432

pub fn defaultRebase(r: *Reader, capacity: usize) Error!void

Parameters

r: *Reader
capacity: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.DelimiterError

error-set

Source line 768

Errors

EndOfStream

For "inclusive" functions, stream ended before the delimiter was found. For "exclusive" functions, stream ended and there are no more bytes to return.

ReadFailed

See the Reader implementation for detailed diagnostics.

StreamTooLong

The delimiter was not found within a number of bytes matching the capacity of the Reader.

std.Io.Reader.discard

function

Source line 181

pub fn discard(r: *Reader, limit: Limit) Error!usize

Parameters

r: *Reader
limit: Limit

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.discardAll

function

Source line 616

Skips the next n bytes from the stream, advancing the seek position.

Unlike toss which is infallible, in this function n can be any amount.

Returns error.EndOfStream if fewer than n bytes could be discarded.

See also:

pub fn discardAll(r: *Reader, n: usize) Error!void

Parameters

r: *Reader
n: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test discardAll {
    var r: Reader = .fixed("foobar");
    try r.discardAll(3);
    try testing.expectEqualStrings("bar", try r.take(3));
    try r.discardAll(0);
    try testing.expectError(error.EndOfStream, r.discardAll(1));
}

std.Io.Reader.discardAll64

function

Source line 620

pub fn discardAll64(r: *Reader, n: u64) Error!void

Parameters

r: *Reader
n: u64

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.discardDelimiterExclusive

function

Source line 1081

Reads from the stream until specified byte is found, discarding all data, excluding the delimiter.

Returns the number of bytes discarded.

Succeeds if stream ends before delimiter found. End of stream can be detected by checking if the delimiter is buffered.

See also:

pub fn discardDelimiterExclusive(r: *Reader, delimiter: u8) ShortError!usize

Parameters

r: *Reader
delimiter: u8

Errors

ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test discardDelimiterExclusive {
    var r: Reader = .fixed("foob\nar");
    try testing.expectEqual(4, try r.discardDelimiterExclusive('\n'));
    try testing.expectEqualStrings("\n", try r.take(1));
    try testing.expectEqual(2, try r.discardDelimiterExclusive('\n'));
    try testing.expectEqual(0, try r.discardDelimiterExclusive('\n'));
}

std.Io.Reader.discardDelimiterInclusive

function

Source line 1059

Reads from the stream until specified byte is found, discarding all data, including the delimiter.

Returns number of bytes discarded, or error.EndOfStream if the delimiter is not found.

See also:

pub fn discardDelimiterInclusive(r: *Reader, delimiter: u8) Error!usize

Parameters

r: *Reader
delimiter: u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test discardDelimiterInclusive {
    var r: Reader = .fixed("foob\nar");
    try testing.expectEqual(5, try r.discardDelimiterInclusive('\n'));
    try testing.expectError(error.EndOfStream, r.discardDelimiterInclusive('\n'));
}

std.Io.Reader.discardDelimiterLimit

function

Source line 1101

Reads from the stream until specified byte is found, discarding all data, excluding the delimiter.

Returns the number of bytes discarded.

Succeeds if stream ends before delimiter found. End of stream can be detected by checking if the delimiter is buffered.

pub fn discardDelimiterLimit(r: *Reader, delimiter: u8, limit: Limit) DiscardDelimiterLimitError!usize

Parameters

r: *Reader
delimiter: u8
limit: Limit

Errors

ReadFailed
StreamTooLong

The delimiter was not found within the limit.

Example usage

test discardDelimiterLimit {
    var r: Reader = .fixed("foob\nar");
    try testing.expectError(error.StreamTooLong, r.discardDelimiterLimit('\n', .limited(4)));
    try testing.expectEqual(0, try r.discardDelimiterLimit('\n', .limited(2)));
    try testing.expectEqualStrings("\n", try r.take(1));
    try testing.expectEqual(2, try r.discardDelimiterLimit('\n', .unlimited));
    try testing.expectEqual(0, try r.discardDelimiterLimit('\n', .unlimited));
}

std.Io.Reader.DiscardDelimiterLimitError

error-set

Source line 1088

Errors

ReadFailed
StreamTooLong

The delimiter was not found within the limit.

std.Io.Reader.discardRemaining

function

Source line 274

Consumes the stream until the end, ignoring all the data, returning the number of bytes discarded.

pub fn discardRemaining(r: *Reader) ShortError!usize

Parameters

r: *Reader

Errors

ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test discardRemaining {
    var r: Reader = .fixed("foobar");
    r.toss(1);
    try testing.expectEqual(5, try r.discardRemaining());
    try testing.expectEqual(0, try r.discardRemaining());
}

std.Io.Reader.discardShort

function

Source line 640

Skips the next n bytes from the stream, advancing the seek position.

Unlike toss which is infallible, in this function n can be any amount.

Returns the number of bytes discarded, which is less than n if and only if the stream reached the end.

See also:

pub fn discardShort(r: *Reader, n: usize) ShortError!usize

Parameters

r: *Reader
n: usize

Errors

ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.ending

constant

Source line 145

*Reader

std.Io.Reader.ending_instance

constant

Source line 144

This is generally safe to @constCast because it has an empty buffer, so there is not really a way to accidentally attempt mutation of these fields.

Reader

std.Io.Reader.endingDiscard

function

Source line 1849

fn endingDiscard(r: *Reader, limit: Limit) Error!usize

Parameters

r: *Reader
limit: Limit

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.endingReadVec

function

Source line 1843

fn endingReadVec(r: *Reader, data: [][]u8) Error!usize

Parameters

r: *Reader
data: [][]u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.endingRebase

function

Source line 1855

fn endingRebase(r: *Reader, capacity: usize) RebaseError!void

Parameters

r: *Reader
capacity: usize

Errors

EndOfStream Error
ReadFailed Error

See the Reader implementation for detailed diagnostics.

std.Io.Reader.endingStream

function

Source line 1836

fn endingStream(r: *Reader, w: *Writer, limit: Limit) StreamError!usize

Parameters

r: *Reader
w: *Writer
limit: Limit

Errors

EndOfStream

End of stream indicated from the Reader. This error cannot originate from the Writer.

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

std.Io.Reader.Error

error-set

Source line 112

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.failing

constant

Source line 132

Reader

std.Io.Reader.failingDiscard

function

Source line 1868

fn failingDiscard(r: *Reader, limit: Limit) Error!usize

Parameters

r: *Reader
limit: Limit

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.failingStream

function

Source line 1861

fn failingStream(r: *Reader, w: *Writer, limit: Limit) StreamError!usize

Parameters

r: *Reader
w: *Writer
limit: Limit

Errors

EndOfStream

End of stream indicated from the Reader. This error cannot originate from the Writer.

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

std.Io.Reader.fill

function

Source line 1127

Fills the buffer such that it contains at least n bytes, without advancing the seek position.

Returns error.EndOfStream if and only if there are fewer than n bytes remaining.

If the end of stream is not encountered, asserts buffer capacity is at least n.

pub fn fill(r: *Reader, n: usize) Error!void

Parameters

r: *Reader
n: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test fill {
    var r: Reader = .fixed("abc");
    try r.fill(1);
    try r.fill(3);
}

std.Io.Reader.fillMore

function

Source line 1154

Without advancing the seek position, does exactly one underlying read, filling the buffer as much as possible. This may result in zero bytes added to the buffer, which is not an end of stream condition. End of stream is communicated via returning error.EndOfStream.

Asserts buffer capacity is at least 1.

pub fn fillMore(r: *Reader) Error!void

Parameters

r: *Reader

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.fillUnbuffered

function

Source line 1143

This internal function is separated from fill to encourage optimizers to inline fill, hence propagating its @branchHint to usage sites. If these functions are combined, fill is large enough that LLVM is reluctant to inline it, forcing usages of APIs like takeInt to go through an expensive runtime function call just to figure out that the data is, in fact, already in the buffer.

Missing this optimization can result in wall-clock time for the most affected benchmarks increasing by a factor of 5 or more.

fn fillUnbuffered(r: *Reader, n: usize) Error!void

Parameters

r: *Reader
n: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.fixed

function

Source line 152

Constructs a Reader such that it will read from buffer and then end.

pub fn fixed(buffer: []const u8) Reader

Parameters

buffer: []const u8

Example usage

test fixed {
    var r: Reader = .fixed("a\x02");
    try testing.expect((try r.takeByte()) == 'a');
    try testing.expect((try r.takeEnum(enum(u8) {
        a = 0,
        b = 99,
        c = 2,
        d = 3,
    }, builtin.cpu.arch.endian())) == .c);
    try testing.expectError(error.EndOfStream, r.takeByte());
}

std.Io.Reader.hashed

function

Source line 486

pub fn hashed(r: *Reader, hasher: anytype, buffer: []u8) Hashed(@TypeOf(hasher))

Parameters

r: *Reader
buffer: []u8

std.Io.Reader.Hashed

type-function

Source line 1990

Provides a Reader implementation by passing data from an underlying reader through Hasher.update.

The underlying reader is best unbuffered.

This implementation makes suboptimal buffering decisions due to being generic. A better solution will involve creating a reader for each hash function, where the discard buffer can be tailored to the hash implementation details.

pub fn Hashed(comptime Hasher: type) type

Parameters

Hasher: type

Fields

in: *Reader
hasher: Hasher
reader: Reader

std.Io.Reader.Hashed.discard

function

Source line 2048

fn discard(r: *Reader, limit: Limit) Error!usize

Parameters

r: *Reader
limit: Limit

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.Hashed.init

function

Source line 1996

pub fn init(in: *Reader, hasher: Hasher, buffer: []u8) @This()

Parameters

in: *Reader
hasher: Hasher
buffer: []u8

std.Io.Reader.Hashed.readVec

function

Source line 2023

fn readVec(r: *Reader, data: [][]u8) Error!usize

Parameters

r: *Reader
data: [][]u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.Hashed.stream

function

Source line 2013

fn stream(r: *Reader, w: *Writer, limit: Limit) StreamError!usize

Parameters

r: *Reader
w: *Writer
limit: Limit

Errors

EndOfStream

End of stream indicated from the Reader. This error cannot originate from the Writer.

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

std.Io.Reader.Limit

alias

Source line 8

Alias of std.Io.Limit

std.Io.Reader.limited

function

Source line 147

pub fn limited(r: *Reader, limit: Limit, buffer: []u8) Limited

Parameters

r: *Reader
limit: Limit
buffer: []u8

std.Io.Reader.Limited

alias

Source line 14

Alias of std.Io.Reader.Limited

std.Io.Reader.LimitedAllocError

error-set

Source line 285

Errors

OutOfMemory Error
ReadFailed ShortError

See the Reader implementation for detailed diagnostics.

StreamTooLong

std.Io.Reader.native_endian

constant

Source line 4

std.Io.Reader.peek

function

Source line 520

Returns the next n bytes from the stream, filling the buffer as necessary.

Invalidates previously returned values from peek.

Asserts that the Reader was initialized with a buffer capacity at least as big as n.

If there are fewer than n bytes left in the stream, error.EndOfStream is returned instead.

See also:

pub fn peek(r: *Reader, n: usize) Error![]u8

Parameters

r: *Reader
n: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test peek {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("ab", try r.peek(2));
    try testing.expectEqualStrings("a", try r.peek(1));
}

std.Io.Reader.peekArray

function

Source line 601

Returns the next n bytes from the stream as an array, filling the buffer as necessary, without advancing the seek position.

Asserts that the Reader was initialized with a buffer capacity at least as big as n.

If there are fewer than n bytes left in the stream, error.EndOfStream is returned instead.

See also:

pub fn peekArray(r: *Reader, comptime n: usize) Error!*[n]u8

Parameters

r: *Reader
n: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test peekArray {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("ab", try r.peekArray(2));
    try testing.expectEqualStrings("a", try r.peekArray(1));
}

std.Io.Reader.peekByte

function

Source line 1165

Returns the next byte from the stream or returns error.EndOfStream.

Does not advance the seek position.

Asserts the buffer capacity is nonzero.

pub fn peekByte(r: *Reader) Error!u8

Parameters

r: *Reader

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.peekDelimiterExclusive

function

Source line 948

Returns a slice of the next bytes of buffered data from the stream until delimiter is found, without advancing the seek position.

Returned slice excludes the delimiter. End-of-stream is treated equivalent to a delimiter, unless it would result in a length 0 return value, in which case error.EndOfStream is returned instead.

If the delimiter is not found within a number of bytes matching the capacity of this Reader, error.StreamTooLong is returned. In such case, the stream state is unmodified as if this function was never called.

Invalidates previously returned values from peek.

See also:

pub fn peekDelimiterExclusive(r: *Reader, delimiter: u8) DelimiterError![]u8

Parameters

r: *Reader
delimiter: u8

Errors

EndOfStream

For "inclusive" functions, stream ended before the delimiter was found. For "exclusive" functions, stream ended and there are no more bytes to return.

ReadFailed

See the Reader implementation for detailed diagnostics.

StreamTooLong

The delimiter was not found within a number of bytes matching the capacity of the Reader.

Example usage

test peekDelimiterExclusive {
    var r: Reader = .fixed("ab\nc");

    try testing.expectEqualStrings("ab", try r.peekDelimiterExclusive('\n'));
    try testing.expectEqualStrings("ab", try r.peekDelimiterExclusive('\n'));
    r.toss(2);
    try testing.expectEqualStrings("", try r.peekDelimiterExclusive('\n'));
    try testing.expectEqualStrings("\n", try r.take(1));

    try testing.expectEqualStrings("c", try r.peekDelimiterExclusive('\n'));
    try testing.expectEqualStrings("c", try r.peekDelimiterExclusive('\n'));
    r.toss(1);
    try testing.expectError(error.EndOfStream, r.peekDelimiterExclusive('\n'));
}

std.Io.Reader.peekDelimiterInclusive

function

Source line 841

Returns a slice of the next bytes of buffered data from the stream until delimiter is found, without advancing the seek position.

Returned slice includes the delimiter as the last byte.

Invalidates previously returned values from peek.

See also:

pub fn peekDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8

Parameters

r: *Reader
delimiter: u8

Errors

EndOfStream

For "inclusive" functions, stream ended before the delimiter was found. For "exclusive" functions, stream ended and there are no more bytes to return.

ReadFailed

See the Reader implementation for detailed diagnostics.

StreamTooLong

The delimiter was not found within a number of bytes matching the capacity of the Reader.

Example usage

test peekDelimiterInclusive {
    var r: Reader = .fixed("ab\nc");
    try testing.expectEqualStrings("ab\n", try r.peekDelimiterInclusive('\n'));
    try testing.expectEqualStrings("ab\n", try r.peekDelimiterInclusive('\n'));
    r.toss(3);
    try testing.expectError(error.EndOfStream, r.peekDelimiterInclusive('\n'));
    try testing.expectEqualStrings("c", try r.peek(1));
}

std.Io.Reader.peekGreedy

function

Source line 539

Returns all the next buffered bytes, after filling the buffer to ensure it contains at least n bytes.

Invalidates previously returned values from peek and peekGreedy.

Asserts that the Reader was initialized with a buffer capacity at least as big as n.

If there are fewer than n bytes left in the stream, error.EndOfStream is returned instead.

See also:

pub fn peekGreedy(r: *Reader, n: usize) Error![]u8

Parameters

r: *Reader
n: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test peekGreedy {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("abc", try r.peekGreedy(1));
}

std.Io.Reader.peekInt

function

Source line 1197

Asserts the buffer was initialized with a capacity at least @bitSizeOf(T) / 8.

pub inline fn peekInt(r: *Reader, comptime T: type, endian: std.builtin.Endian) Error!T

Parameters

r: *Reader
T: type
endian: std.builtin.Endian

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.peekSentinel

function

Source line 808

Returns a slice of the next bytes of buffered data from the stream until sentinel is found, without advancing the seek position.

Returned slice has a sentinel; end of stream does not count as a delimiter.

Invalidates previously returned values from peek.

See also:

pub fn peekSentinel(r: *Reader, comptime sentinel: u8) DelimiterError![:sentinel]u8

Parameters

r: *Reader
sentinel: u8

Errors

EndOfStream

For "inclusive" functions, stream ended before the delimiter was found. For "exclusive" functions, stream ended and there are no more bytes to return.

ReadFailed

See the Reader implementation for detailed diagnostics.

StreamTooLong

The delimiter was not found within a number of bytes matching the capacity of the Reader.

Example usage

test peekSentinel {
    var r: Reader = .fixed("ab\nc");
    try testing.expectEqualStrings("ab", try r.peekSentinel('\n'));
    try testing.expectEqualStrings("ab", try r.peekSentinel('\n'));
    r.toss(3);
    try testing.expectError(error.EndOfStream, r.peekSentinel('\n'));
    try testing.expectEqualStrings("c", try r.peek(1));
}

std.Io.Reader.peekStruct

function

Source line 1267

Asserts the buffer was initialized with a capacity at least @sizeOf(T).

This function is inline to avoid referencing std.mem.byteSwapAllFields when endian is comptime-known and matches the host endianness.

See also:

pub inline fn peekStruct(r: *Reader, comptime T: type, endian: std.builtin.Endian) Error!T

Parameters

r: *Reader
T: type
endian: std.builtin.Endian

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test peekStruct {
    var r: Reader = .fixed(&.{ 0x12, 0x00, 0x34, 0x56 });
    const S = extern struct { a: u8, b: u16 };
    try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), try r.peekStruct(S, .big));
    try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x5634 }), try r.peekStruct(S, .little));
}

std.Io.Reader.peekStructPointer

function

Source line 1230

Obtains an unaligned pointer to the beginning of the stream, reinterpreted as a pointer to the provided type, without advancing the seek position.

Asserts the buffer was initialized with a capacity at least @sizeOf(T).

See also:

pub fn peekStructPointer(r: *Reader, comptime T: type) Error!*align(1) T

Parameters

r: *Reader
T: type

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test peekStructPointer {
    var r: Reader = .fixed(&.{ 0x12, 0x00, 0x34, 0x56 });
    const S = extern struct { a: u8, b: u16 };
    switch (native_endian) {
        .little => {
            try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x5634 }), (try r.peekStructPointer(S)).*);
            try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x5634 }), (try r.peekStructPointer(S)).*);
        },
        .big => {
            try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), (try r.peekStructPointer(S)).*);
            try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), (try r.peekStructPointer(S)).*);
        },
    }
}

std.Io.Reader.readAlloc

alias

Source line 748

Deprecated; use readAllocAll. to be removed after 0.17.

Alias of std.Io.Reader.readAllocAll

std.Io.Reader.readAllocAll

function

Source line 751

Shortcut for calling readSliceAll with a buffer provided by allocator.

pub fn readAllocAll(r: *Reader, allocator: Allocator, len: usize) ReadAllocError![]u8

Parameters

r: *Reader
allocator: Allocator
len: usize

Errors

EndOfStream Error
OutOfMemory Error
ReadFailed Error

See the Reader implementation for detailed diagnostics.

Example usage

test readAllocAll {
    const allocator = testing.allocator;
    var r: Reader = .fixed("HelloFren");

    const s1 = try r.readAllocAll(allocator, 5);
    defer allocator.free(s1);
    try testing.expectEqualStrings("Hello", s1);

    const s2 = try r.readAllocAll(allocator, 4);
    defer allocator.free(s2);
    try testing.expectEqualStrings("Fren", s2);
}

std.Io.Reader.ReadAllocError

error-set

Source line 730

Errors

EndOfStream Error
OutOfMemory Error
ReadFailed Error

See the Reader implementation for detailed diagnostics.

std.Io.Reader.readAllocShort

function

Source line 760

Shortcut for calling readSliceShort with a buffer provided by allocator, shrinking allocation if stream reached the end.

pub fn readAllocShort(r: *Reader, allocator: Allocator, len: usize) ReadAllocError![]u8

Parameters

r: *Reader
allocator: Allocator
len: usize

Errors

EndOfStream Error
OutOfMemory Error
ReadFailed Error

See the Reader implementation for detailed diagnostics.

Example usage

test readAllocShort {
    var r: Reader = .fixed("HelloFren");

    const s1 = try r.readAllocShort(testing.allocator, 5);
    defer testing.allocator.free(s1);
    try testing.expectEqualStrings("Hello", s1);

    const s2 = try r.readAllocShort(testing.allocator, 10);
    defer testing.allocator.free(s2);
    try testing.expectEqualStrings("Fren", s2);

    const s3 = try r.readAllocShort(testing.allocator, 10);
    defer testing.allocator.free(s3);
    try testing.expectEqual(0, s3.len);
}

std.Io.Reader.Reader

alias

Source line 1

Alias of std.Io.Reader

std.Io.Reader.readSliceAll

function

Source line 670

Fill buffer with the next buffer.len bytes from the stream, advancing the seek position.

Invalidates previously returned values from peek.

If the provided buffer cannot be filled completely, error.EndOfStream is returned instead.

See also:

pub fn readSliceAll(r: *Reader, buffer: []u8) Error!void

Parameters

r: *Reader
buffer: []u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.readSliceEndian

function

Source line 720

Fill buffer with the next buffer.len bytes from the stream, advancing the seek position.

Invalidates previously returned values from peek.

If the provided buffer cannot be filled completely, error.EndOfStream is returned instead.

The function is inline to avoid the dead code in case endian is comptime-known and matches host endianness.

See also:

pub inline fn readSliceEndian( r: *Reader, comptime Elem: type, buffer: []Elem, endian: std.builtin.Endian, ) Error!void

Parameters

r: *Reader
Elem: type
buffer: []Elem
endian: std.builtin.Endian

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.readSliceEndianAlloc

function

Source line 734

The function is inline to avoid the dead code in case endian is comptime-known and matches host endianness.

pub inline fn readSliceEndianAlloc( r: *Reader, allocator: Allocator, comptime Elem: type, len: usize, endian: std.builtin.Endian, ) ReadAllocError![]Elem

Parameters

r: *Reader
allocator: Allocator
Elem: type
len: usize
endian: std.builtin.Endian

Errors

EndOfStream Error
OutOfMemory Error
ReadFailed Error

See the Reader implementation for detailed diagnostics.

std.Io.Reader.readSliceShort

function

Source line 685

Fill buffer with the next buffer.len bytes from the stream, advancing the seek position.

Invalidates previously returned values from peek.

Returns the number of bytes read, which is less than buffer.len if and only if the stream reached the end.

See also:

pub fn readSliceShort(r: *Reader, buffer: []u8) ShortError!usize

Parameters

r: *Reader
buffer: []u8

Errors

ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test readSliceShort {
    var r: Reader = .fixed("HelloFren");
    var buf: [5]u8 = undefined;
    try testing.expectEqual(5, try r.readSliceShort(&buf));
    try testing.expectEqualStrings("Hello", buf[0..5]);
    try testing.expectEqual(4, try r.readSliceShort(&buf));
    try testing.expectEqualStrings("Fren", buf[0..4]);
    try testing.expectEqual(0, try r.readSliceShort(&buf));
}

std.Io.Reader.readVec

function

Source line 425

Writes bytes from the internally tracked stream position to data.

Returns the number of bytes written, which will be at minimum 0 and at most the sum of each data slice length. The number of bytes read, including zero, does not indicate end of stream.

The reader's internal logical seek position moves forward in accordance with the number of bytes returned from this function.

pub fn readVec(r: *Reader, data: [][]u8) Error!usize

Parameters

r: *Reader
data: [][]u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test readVec {
    var r: Reader = .fixed(std.ascii.letters);
    var flat_buffer: [52]u8 = undefined;
    var bufs: [2][]u8 = .{
        flat_buffer[0..26],
        flat_buffer[26..],
    };
    // Short reads are possible with this function but not with fixed.
    try testing.expectEqual(26 * 2, try r.readVec(&bufs));
    try testing.expectEqualStrings(std.ascii.letters[0..26], bufs[0]);
    try testing.expectEqualStrings(std.ascii.letters[26..], bufs[1]);
}

std.Io.Reader.readVecAll

function

Source line 490

pub fn readVecAll(r: *Reader, data: [][]u8) Error!void

Parameters

r: *Reader
data: [][]u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.rebase

function

Source line 1424

Ensures capacity data can be buffered without rebasing.

pub fn rebase(r: *Reader, capacity: usize) Error!void

Parameters

r: *Reader
capacity: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.RebaseError

alias

Source line 130

Alias of std.Io.Reader.Error

std.Io.Reader.ShortError

error-set

Source line 125

Errors

ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.std

alias

Source line 6

Alias of std

std.Io.Reader.stream

function

Source line 168

pub fn stream(r: *Reader, w: *Writer, limit: Limit) StreamError!usize

Parameters

r: *Reader
w: *Writer
limit: Limit

Errors

EndOfStream

End of stream indicated from the Reader. This error cannot originate from the Writer.

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

Example usage

test stream {
    var out_buffer: [10]u8 = undefined;
    var r: Reader = .fixed("foobar");
    var w: Writer = .fixed(&out_buffer);
    // Short streams are possible with this function but not with fixed.
    try testing.expectEqual(2, try r.stream(&w, .limited(2)));
    try testing.expectEqualStrings("fo", w.buffered());
    try testing.expectEqual(4, try r.stream(&w, .unlimited));
    try testing.expectEqualStrings("foobar", w.buffered());
}

std.Io.Reader.streamDelimiter

function

Source line 974

Appends to w contents by reading from the stream until delimiter is found. Does not write the delimiter itself.

Does not discard the delimiter from the Reader.

Returns number of bytes streamed, which may be zero, or error.EndOfStream if the delimiter was not found.

Asserts buffer capacity of at least one. This function performs better with larger buffers.

See also:

pub fn streamDelimiter(r: *Reader, w: *Writer, delimiter: u8) StreamError!usize

Parameters

r: *Reader
w: *Writer
delimiter: u8

Errors

EndOfStream

End of stream indicated from the Reader. This error cannot originate from the Writer.

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

Example usage

test streamDelimiter {
    var out_buffer: [10]u8 = undefined;
    var r: Reader = .fixed("foo\nbars");
    var w: Writer = .fixed(&out_buffer);
    try testing.expectEqual(3, try r.streamDelimiter(&w, '\n'));
    try testing.expectEqualStrings("foo", w.buffered());
    try testing.expectEqual(0, try r.streamDelimiter(&w, '\n'));
    r.toss(1);
    try testing.expectError(error.EndOfStream, r.streamDelimiter(&w, '\n'));
}

std.Io.Reader.streamDelimiterEnding

function

Source line 997

Appends to w contents by reading from the stream until delimiter is found. Does not write the delimiter itself.

Returns number of bytes streamed, which may be zero. If the stream reaches the end, the reader buffer will be empty when this function returns. Otherwise, it will have at least one byte buffered, starting with the delimiter.

Asserts buffer capacity of at least one. This function performs better with larger buffers.

See also:

pub fn streamDelimiterEnding( r: *Reader, w: *Writer, delimiter: u8, ) StreamRemainingError!usize

Parameters

r: *Reader
w: *Writer
delimiter: u8

Errors

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

Example usage

test streamDelimiterEnding {
    var out_buffer: [10]u8 = undefined;
    var r: Reader = .fixed("foo\nbars");
    var w: Writer = .fixed(&out_buffer);
    try testing.expectEqual(3, try r.streamDelimiterEnding(&w, '\n'));
    try testing.expectEqualStrings("foo", w.buffered());
    r.toss(1);
    try testing.expectEqual(4, try r.streamDelimiterEnding(&w, '\n'));
    try testing.expectEqualStrings("foobars", w.buffered());
    try testing.expectEqual(0, try r.streamDelimiterEnding(&w, '\n'));
    try testing.expectEqual(0, try r.streamDelimiterEnding(&w, '\n'));
}

std.Io.Reader.streamDelimiterLimit

function

Source line 1025

Appends to w contents by reading from the stream until delimiter is found. Does not write the delimiter itself.

Does not discard the delimiter from the Reader.

Returns number of bytes streamed, which may be zero. End of stream can be detected by checking if the next byte in the stream is the delimiter.

Asserts buffer capacity of at least one. This function performs better with larger buffers.

pub fn streamDelimiterLimit( r: *Reader, w: *Writer, delimiter: u8, limit: Limit, ) StreamDelimiterLimitError!usize

Parameters

r: *Reader
w: *Writer
delimiter: u8
limit: Limit

Errors

ReadFailed
StreamTooLong

The delimiter was not found within the limit.

WriteFailed

Example usage

test streamDelimiterLimit {
    var out_buffer: [10]u8 = undefined;
    var r: Reader = .fixed("foo\nbars");
    var w: Writer = .fixed(&out_buffer);
    try testing.expectError(error.StreamTooLong, r.streamDelimiterLimit(&w, '\n', .limited(2)));
    try testing.expectEqual(1, try r.streamDelimiterLimit(&w, '\n', .limited(3)));
    try testing.expectEqualStrings("\n", try r.take(1));
    try testing.expectEqual(4, try r.streamDelimiterLimit(&w, '\n', .unlimited));
    try testing.expectEqualStrings("foobars", w.buffered());
}

std.Io.Reader.StreamDelimiterLimitError

error-set

Source line 1008

Errors

ReadFailed
StreamTooLong

The delimiter was not found within the limit.

WriteFailed

std.Io.Reader.StreamError

error-set

Source line 102

Errors

EndOfStream

End of stream indicated from the Reader. This error cannot originate from the Writer.

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

std.Io.Reader.streamExact

function

Source line 216

"Pump" exactly n bytes from the reader to the writer.

pub fn streamExact(r: *Reader, w: *Writer, n: usize) StreamError!void

Parameters

r: *Reader
w: *Writer
n: usize

Errors

EndOfStream

End of stream indicated from the Reader. This error cannot originate from the Writer.

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

std.Io.Reader.streamExact64

function

Source line 222

"Pump" exactly n bytes from the reader to the writer.

pub fn streamExact64(r: *Reader, w: *Writer, n: u64) StreamError!void

Parameters

r: *Reader
w: *Writer
n: u64

Errors

EndOfStream

End of stream indicated from the Reader. This error cannot originate from the Writer.

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

std.Io.Reader.streamExactPreserve

function

Source line 239

"Pump" exactly n bytes from the reader to the writer.

On success, at least preserve_len bytes will remain buffered if there are enough buffered bytes to do so. The amount buffered by the writer after the call will only be less than preserve_len if w.end + n is less than preserve_len before the call. The intentionally preserved bytes will include up to preserve_len -| n bytes from the previously buffered bytes, plus @min(n, preserve_len) of the newly "pumped" bytes.

Asserts Writer.buffer capacity is at least preserve_len. n can be greater than the Writer.buffer capacity.

pub fn streamExactPreserve(r: *Reader, w: *Writer, preserve_len: usize, n: usize) StreamError!void

Parameters

r: *Reader
w: *Writer
preserve_len: usize
n: usize

Errors

EndOfStream

End of stream indicated from the Reader. This error cannot originate from the Writer.

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

Example usage

test streamExactPreserve {
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .stream_len = 5 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 9, .preserve = 5, .stream_len = 2 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .stream_len = 6 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 6 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .stream_len = 10 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 10 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 11 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 80 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 85 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 6 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 11 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 80 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 85 });
}

std.Io.Reader.streamRemaining

function

Source line 262

"Pump" data from the reader to the writer, handling error.EndOfStream as a success case.

Returns total number of bytes written to w.

pub fn streamRemaining(r: *Reader, w: *Writer) StreamRemainingError!usize

Parameters

r: *Reader
w: *Writer

Errors

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

std.Io.Reader.StreamRemainingError

error-set

Source line 118

Errors

ReadFailed

See the Reader implementation for detailed diagnostics.

WriteFailed

See the Writer implementation for detailed diagnostics.

std.Io.Reader.take

function

Source line 568

Equivalent to peek followed by toss.

The data returned is invalidated by the next call to take, peek, fill, and functions with those prefixes.

pub fn take(r: *Reader, n: usize) Error![]u8

Parameters

r: *Reader
n: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test take {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("ab", try r.take(2));
    try testing.expectEqualStrings("c", try r.take(1));
}

std.Io.Reader.takeArray

function

Source line 585

Returns the next n bytes from the stream as an array, filling the buffer as necessary and advancing the seek position n bytes.

Asserts that the Reader was initialized with a buffer capacity at least as big as n.

If there are fewer than n bytes left in the stream, error.EndOfStream is returned instead.

See also:

pub fn takeArray(r: *Reader, comptime n: usize) Error!*[n]u8

Parameters

r: *Reader
n: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test takeArray {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("ab", try r.takeArray(2));
    try testing.expectEqualStrings("c", try r.takeArray(1));
}

std.Io.Reader.takeByte

function

Source line 1179

Reads 1 byte from the stream or returns error.EndOfStream.

Asserts the buffer capacity is nonzero.

pub fn takeByte(r: *Reader) Error!u8

Parameters

r: *Reader

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test takeByte {
    var r: Reader = .fixed("ab");
    try testing.expectEqual('a', try r.takeByte());
    try testing.expectEqual('b', try r.takeByte());
    try testing.expectError(error.EndOfStream, r.takeByte());
}

std.Io.Reader.takeByteSigned

function

Source line 1186

Same as takeByte except the returned byte is signed.

pub fn takeByteSigned(r: *Reader) Error!i8

Parameters

r: *Reader

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test takeByteSigned {
    var r: Reader = .fixed(&.{ 255, 5 });
    try testing.expectEqual(-1, try r.takeByteSigned());
    try testing.expectEqual(5, try r.takeByteSigned());
    try testing.expectError(error.EndOfStream, r.takeByteSigned());
}

std.Io.Reader.takeDelimiter

function

Source line 917

Returns a slice of the next bytes of buffered data from the stream until delimiter is found, advancing the seek position past the delimiter.

Returned slice excludes the delimiter. End-of-stream is treated equivalent to a delimiter, unless it would result in a length 0 return value, in which case null is returned instead.

If the delimiter is not found within a number of bytes matching the capacity of this Reader, error.StreamTooLong is returned. In such case, the stream state is unmodified as if this function was never called.

Invalidates previously returned values from peek.

See also:

pub fn takeDelimiter(r: *Reader, delimiter: u8) error{ ReadFailed, StreamTooLong }!?[]u8

Parameters

r: *Reader
delimiter: u8

Errors

ReadFailed
StreamTooLong

Example usage

test takeDelimiter {
    var r: Reader = .fixed("ab\nc\n\nd");
    try testing.expectEqualStrings("ab", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("c", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("d", (try r.takeDelimiter('\n')).?);
    try testing.expectEqual(null, try r.takeDelimiter('\n'));
    try testing.expectEqual(null, try r.takeDelimiter('\n'));

    r = .fixed("ab\nc\n\nd\n"); // one trailing newline does not affect behavior
    try testing.expectEqualStrings("ab", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("c", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("d", (try r.takeDelimiter('\n')).?);
    try testing.expectEqual(null, try r.takeDelimiter('\n'));
    try testing.expectEqual(null, try r.takeDelimiter('\n'));
}

std.Io.Reader.takeDelimiterExclusive

function

Source line 894

Returns a slice of the next bytes of buffered data from the stream until delimiter is found, advancing the seek position up to (but not past) the delimiter.

Returned slice excludes the delimiter. End-of-stream is treated equivalent to a delimiter, unless it would result in a length 0 return value, in which case error.EndOfStream is returned instead.

If the delimiter is not found within a number of bytes matching the capacity of this Reader, error.StreamTooLong is returned. In such case, the stream state is unmodified as if this function was never called.

Invalidates previously returned values from peek.

See also:

pub fn takeDelimiterExclusive(r: *Reader, delimiter: u8) DelimiterError![]u8

Parameters

r: *Reader
delimiter: u8

Errors

EndOfStream

For "inclusive" functions, stream ended before the delimiter was found. For "exclusive" functions, stream ended and there are no more bytes to return.

ReadFailed

See the Reader implementation for detailed diagnostics.

StreamTooLong

The delimiter was not found within a number of bytes matching the capacity of the Reader.

Example usage

test takeDelimiterExclusive {
    var r: Reader = .fixed("ab\nc");

    try testing.expectEqualStrings("ab", try r.takeDelimiterExclusive('\n'));
    try testing.expectEqualStrings("", try r.takeDelimiterExclusive('\n'));
    try testing.expectEqualStrings("", try r.takeDelimiterExclusive('\n'));
    try testing.expectEqualStrings("\n", try r.take(1));

    try testing.expectEqualStrings("c", try r.takeDelimiterExclusive('\n'));
    try testing.expectError(error.EndOfStream, r.takeDelimiterExclusive('\n'));
}

std.Io.Reader.takeDelimiterInclusive

function

Source line 824

Returns a slice of the next bytes of buffered data from the stream until delimiter is found, advancing the seek position past the delimiter.

Returned slice includes the delimiter as the last byte.

Invalidates previously returned values from peek.

See also:

pub fn takeDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8

Parameters

r: *Reader
delimiter: u8

Errors

EndOfStream

For "inclusive" functions, stream ended before the delimiter was found. For "exclusive" functions, stream ended and there are no more bytes to return.

ReadFailed

See the Reader implementation for detailed diagnostics.

StreamTooLong

The delimiter was not found within a number of bytes matching the capacity of the Reader.

Example usage

test takeDelimiterInclusive {
    var r: Reader = .fixed("ab\nc");
    try testing.expectEqualStrings("ab\n", try r.takeDelimiterInclusive('\n'));
    try testing.expectError(error.EndOfStream, r.takeDelimiterInclusive('\n'));
}

std.Io.Reader.takeEnum

function

Source line 1291

Reads an integer with the same size as the given enum's tag type. If the integer matches an enum tag, casts the integer to the enum tag and returns it. Otherwise, returns error.InvalidEnumTag.

Asserts the buffer was initialized with a capacity at least @sizeOf(Enum).

pub fn takeEnum(r: *Reader, comptime Enum: type, endian: std.builtin.Endian) TakeEnumError!Enum

Parameters

r: *Reader
Enum: type
endian: std.builtin.Endian

Errors

EndOfStream Error
InvalidEnumTag
ReadFailed Error

See the Reader implementation for detailed diagnostics.

Example usage

test takeEnum {
    var r: Reader = .fixed(&.{ 2, 0, 1 });
    const E1 = enum(u8) { a, b, c };
    const E2 = enum(u16) { _ };
    try testing.expectEqual(E1.c, try r.takeEnum(E1, .little));
    try testing.expectEqual(@as(E2, @fromBackingInt(@intCast(0x0001))), try r.takeEnum(E2, .big));
}

std.Io.Reader.TakeEnumError

error-set

Source line 1284

Errors

EndOfStream Error
InvalidEnumTag
ReadFailed Error

See the Reader implementation for detailed diagnostics.

std.Io.Reader.takeEnumNonexhaustive

function

Source line 1300

Reads an integer with the same size as the given nonexhaustive enum's tag type.

Asserts the buffer was initialized with a capacity at least @sizeOf(Enum).

pub fn takeEnumNonexhaustive(r: *Reader, comptime Enum: type, endian: std.builtin.Endian) Error!Enum

Parameters

r: *Reader
Enum: type
endian: std.builtin.Endian

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.takeInt

function

Source line 1191

Asserts the buffer was initialized with a capacity at least @bitSizeOf(T) / 8.

pub inline fn takeInt(r: *Reader, comptime T: type, endian: std.builtin.Endian) Error!T

Parameters

r: *Reader
T: type
endian: std.builtin.Endian

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test takeInt {
    var r: Reader = .fixed(&.{ 0x12, 0x34, 0x56 });
    try testing.expectEqual(0x1234, try r.takeInt(u16, .big));
    try testing.expectError(error.EndOfStream, r.takeInt(u16, .little));
}

std.Io.Reader.takeLeb128

function

Source line 1313

Read a single LEB128 value as type T, or error.Overflow if the value cannot fit.

pub fn takeLeb128(r: *Reader, comptime T: type) TakeLeb128Error!T

Parameters

r: *Reader
T: type

Errors

EndOfStream Error
Overflow
ReadFailed Error

See the Reader implementation for detailed diagnostics.

std.Io.Reader.TakeLeb128Error

error-set

Source line 1310

Errors

EndOfStream Error
Overflow
ReadFailed Error

See the Reader implementation for detailed diagnostics.

std.Io.Reader.takeSentinel

function

Source line 791

Returns a slice of the next bytes of buffered data from the stream until sentinel is found, advancing the seek position past the sentinel.

Returned slice has a sentinel.

Invalidates previously returned values from peek.

See also:

pub fn takeSentinel(r: *Reader, comptime sentinel: u8) DelimiterError![:sentinel]u8

Parameters

r: *Reader
sentinel: u8

Errors

EndOfStream

For "inclusive" functions, stream ended before the delimiter was found. For "exclusive" functions, stream ended and there are no more bytes to return.

ReadFailed

See the Reader implementation for detailed diagnostics.

StreamTooLong

The delimiter was not found within a number of bytes matching the capacity of the Reader.

Example usage

test takeSentinel {
    var r: Reader = .fixed("ab\nc");
    try testing.expectEqualStrings("ab", try r.takeSentinel('\n'));
    try testing.expectError(error.EndOfStream, r.takeSentinel('\n'));
    try testing.expectEqualStrings("c", try r.peek(1));
}

std.Io.Reader.takeStruct

function

Source line 1242

This function is inline to avoid referencing std.mem.byteSwapAllFields when endian is comptime-known and matches the host endianness.

See also:

pub inline fn takeStruct(r: *Reader, comptime T: type, endian: std.builtin.Endian) Error!T

Parameters

r: *Reader
T: type
endian: std.builtin.Endian

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test takeStruct {
    var r: Reader = .fixed(&.{ 0x12, 0x00, 0x34, 0x56 });
    const S = extern struct { a: u8, b: u16 };
    try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), try r.takeStruct(S, .big));
    try testing.expectError(error.EndOfStream, r.takeStruct(S, .little));
}

std.Io.Reader.takeStructPointer

function

Source line 1216

Obtains an unaligned pointer to the beginning of the stream, reinterpreted as a pointer to the provided type, advancing the seek position.

Asserts the buffer was initialized with a capacity at least @sizeOf(T).

See also:

pub fn takeStructPointer(r: *Reader, comptime T: type) Error!*align(1) T

Parameters

r: *Reader
T: type

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test takeStructPointer {
    var r: Reader = .fixed(&.{ 0x12, 0x00, 0x34, 0x56 });
    const S = extern struct { a: u8, b: u16 };
    switch (native_endian) {
        .little => try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x5634 }), (try r.takeStructPointer(S)).*),
        .big => try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), (try r.takeStructPointer(S)).*),
    }
    try testing.expectError(error.EndOfStream, r.takeStructPointer(S));
}

std.Io.Reader.takeVarInt

function

Source line 1203

Asserts the buffer was initialized with a capacity at least n.

pub fn takeVarInt(r: *Reader, comptime Int: type, endian: std.builtin.Endian, n: usize) Error!Int

Parameters

r: *Reader
Int: type
endian: std.builtin.Endian
n: usize

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

Example usage

test takeVarInt {
    var r: Reader = .fixed(&.{ 0x12, 0x34, 0x56 });
    try testing.expectEqual(0x123456, try r.takeVarInt(u64, .big, 3));
    try testing.expectError(error.EndOfStream, r.takeVarInt(u16, .little, 1));
}

std.Io.Reader.testing

alias

Source line 10

Alias of std.testing

std.Io.Reader.testLeb128

function

Source line 2384

fn testLeb128(comptime T: type, encoded: []const u8) !T

Parameters

T: type
encoded: []const u8

std.Io.Reader.testStreamExactPreserve

function

Source line 2407

fn testStreamExactPreserve(options: struct { buf_len: u4, fill_len: u4, preserve: u4, stream_len: u8 }) !void

Parameters

options: struct { buf_len: u4, fill_len: u4, preserve: u4, stream_len: u8 }

std.Io.Reader.toss

function

Source line 554

Skips the next n bytes from the stream, advancing the seek position. This is typically and safely used after peek.

Asserts that the number of bytes buffered is at least as many as n.

The "tossed" memory remains alive until a "peek" operation occurs.

See also:

pub fn toss(r: *Reader, n: usize) void

Parameters

r: *Reader
n: usize

Example usage

test toss {
    var r: Reader = .fixed("abc");
    r.toss(1);
    try testing.expectEqualStrings("bc", r.buffered());
}

std.Io.Reader.tossBuffered

function

Source line 560

Equivalent to toss(r.bufferedLen()).

pub fn tossBuffered(r: *Reader) void

Parameters

r: *Reader

std.Io.Reader.UnlimitedAllocError

error-set

Source line 397

Errors

OutOfMemory Error
ReadFailed ShortError

See the Reader implementation for detailed diagnostics.

std.Io.Reader.VTable

container

Source line 23

Fields

stream: *const fn (r: *Reader, w: *Writer, limit: Limit) StreamError!usize

Writes bytes from the internally tracked logical position to w.

Returns the number of bytes written, which will be at minimum 0 and at most limit. The number returned, including zero, does not indicate end of stream.

The reader's internal logical seek position moves forward in accordance with the number of bytes returned from this function.

Implementations are encouraged to utilize mandatory minimum buffer sizes combined with short reads (returning a value less than limit) in order to minimize complexity.

Although this function is usually called when buffer is empty, it is also called when it needs to be filled more due to the API user requesting contiguous memory. In either case, the existing buffer data should be ignored; new data written to w.

In addition to, or instead of writing to w, the implementation may choose to store data in buffer, modifying seek and end accordingly. Implementations are encouraged to take advantage of this if it simplifies the logic.

discard: *const fn (r: *Reader, limit: Limit) Error!usize = defaultDiscard

Consumes bytes from the internally tracked stream position without providing access to them.

Returns the number of bytes discarded, which will be at minimum 0 and at most limit. The number of bytes returned, including zero, does not indicate end of stream.

The reader's internal logical seek position moves forward in accordance with the number of bytes returned from this function.

Implementations are encouraged to utilize mandatory minimum buffer sizes combined with short reads (returning a value less than limit) in order to minimize complexity.

The default implementation is is based on calling stream, borrowing buffer to construct a temporary Writer and ignoring the written data.

This function is only called when buffer is empty.

readVec: *const fn (r: *Reader, data: [][]u8) Error!usize = defaultReadVec

Returns number of bytes written to data.

data must have nonzero length. data[0] may have zero length, in which case the implementation must write to Reader.buffer.

data may not contain an alias to Reader.buffer.

data is mutable because the implementation may temporarily modify the fields in order to handle partial reads. Implementations must restore the original value before returning.

Implementations may ignore data, writing directly to Reader.buffer, modifying seek and end accordingly, and returning 0 from this function. Implementations are encouraged to take advantage of this if it simplifies the logic.

The default implementation calls stream with either data[0] or Reader.buffer, whichever is bigger.

rebase: *const fn (r: *Reader, capacity: usize) RebaseError!void = defaultRebase

Ensures capacity data can be buffered without rebasing.

Asserts capacity is within buffer capacity, or that the stream ends within capacity bytes.

Only called when capacity cannot be satisfied by unused capacity of buffer.

The default implementation moves buffered data to the start of buffer, setting seek to zero, and cannot fail.

std.Io.Reader.writableVector

function

Source line 2128

pub fn writableVector(r: *Reader, buffer: [][]u8, data: []const []u8) Error!struct { usize, usize }

Parameters

r: *Reader
buffer: [][]u8
data: []const []u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.writableVectorPosix

function

Source line 2058

pub fn writableVectorPosix(r: *Reader, buffer: []std.posix.iovec, data: []const []u8) Error!struct { usize, usize }

Parameters

r: *Reader
buffer: []std.posix.iovec
data: []const []u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.writableVectorWsa

function

Source line 2085

pub fn writableVectorWsa( r: *Reader, buffer: []std.os.windows.AFD.WSABUF(.@"var"), data: []const []u8, ) Error!struct { usize, usize }

Parameters

r: *Reader
buffer: []std.os.windows.AFD.WSABUF(.@"var")
data: []const []u8

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.Writer

alias

Source line 7

Alias of std.Io.Writer

Source code

std/Io/Reader.zig

const Reader = @This();

const builtin = @import("builtin");
const native_endian = builtin.target.cpu.arch.endian();

const std = @import("../std.zig");
const Writer = std.Io.Writer;
const Limit = std.Io.Limit;
const assert = std.debug.assert;
const testing = std.testing;
const Allocator = std.mem.Allocator;
const ArrayList = std.ArrayList;

pub const Limited = @import("Reader/Limited.zig");

vtable: *const VTable,
buffer: []u8,
/// Number of bytes which have been consumed from `buffer`.
seek: usize,
/// In `buffer` before this are buffered bytes, after this is `undefined`.
end: usize,

pub const VTable = struct {
    /// Writes bytes from the internally tracked logical position to `w`.
    ///
    /// Returns the number of bytes written, which will be at minimum `0` and
    /// at most `limit`. The number returned, including zero, does not indicate
    /// end of stream.
    ///
    /// The reader's internal logical seek position moves forward in accordance
    /// with the number of bytes returned from this function.
    ///
    /// Implementations are encouraged to utilize mandatory minimum buffer
    /// sizes combined with short reads (returning a value less than `limit`)
    /// in order to minimize complexity.
    ///
    /// Although this function is usually called when `buffer` is empty, it is
    /// also called when it needs to be filled more due to the API user
    /// requesting contiguous memory. In either case, the existing buffer data
    /// should be ignored; new data written to `w`.
    ///
    /// In addition to, or instead of writing to `w`, the implementation may
    /// choose to store data in `buffer`, modifying `seek` and `end`
    /// accordingly. Implementations are encouraged to take advantage of
    /// this if it simplifies the logic.
    stream: *const fn (r: *Reader, w: *Writer, limit: Limit) StreamError!usize,

    /// Consumes bytes from the internally tracked stream position without
    /// providing access to them.
    ///
    /// Returns the number of bytes discarded, which will be at minimum `0` and
    /// at most `limit`. The number of bytes returned, including zero, does not
    /// indicate end of stream.
    ///
    /// The reader's internal logical seek position moves forward in accordance
    /// with the number of bytes returned from this function.
    ///
    /// Implementations are encouraged to utilize mandatory minimum buffer
    /// sizes combined with short reads (returning a value less than `limit`)
    /// in order to minimize complexity.
    ///
    /// The default implementation is is based on calling `stream`, borrowing
    /// `buffer` to construct a temporary `Writer` and ignoring the written
    /// data.
    ///
    /// This function is only called when `buffer` is empty.
    discard: *const fn (r: *Reader, limit: Limit) Error!usize = defaultDiscard,

    /// Returns number of bytes written to `data`.
    ///
    /// `data` must have nonzero length. `data[0]` may have zero length, in
    /// which case the implementation must write to `Reader.buffer`.
    ///
    /// `data` may not contain an alias to `Reader.buffer`.
    ///
    /// `data` is mutable because the implementation may temporarily modify the
    /// fields in order to handle partial reads. Implementations must restore
    /// the original value before returning.
    ///
    /// Implementations may ignore `data`, writing directly to `Reader.buffer`,
    /// modifying `seek` and `end` accordingly, and returning 0 from this
    /// function. Implementations are encouraged to take advantage of this if
    /// it simplifies the logic.
    ///
    /// The default implementation calls `stream` with either `data[0]` or
    /// `Reader.buffer`, whichever is bigger.
    readVec: *const fn (r: *Reader, data: [][]u8) Error!usize = defaultReadVec,

    /// Ensures `capacity` data can be buffered without rebasing.
    ///
    /// Asserts `capacity` is within buffer capacity, or that the stream ends
    /// within `capacity` bytes.
    ///
    /// Only called when `capacity` cannot be satisfied by unused capacity of
    /// `buffer`.
    ///
    /// The default implementation moves buffered data to the start of
    /// `buffer`, setting `seek` to zero, and cannot fail.
    rebase: *const fn (r: *Reader, capacity: usize) RebaseError!void = defaultRebase,
};

pub const StreamError = error{
    /// See the `Reader` implementation for detailed diagnostics.
    ReadFailed,
    /// See the `Writer` implementation for detailed diagnostics.
    WriteFailed,
    /// End of stream indicated from the `Reader`. This error cannot originate
    /// from the `Writer`.
    EndOfStream,
};

pub const Error = error{
    /// See the `Reader` implementation for detailed diagnostics.
    ReadFailed,
    EndOfStream,
};

pub const StreamRemainingError = error{
    /// See the `Reader` implementation for detailed diagnostics.
    ReadFailed,
    /// See the `Writer` implementation for detailed diagnostics.
    WriteFailed,
};

pub const ShortError = error{
    /// See the `Reader` implementation for detailed diagnostics.
    ReadFailed,
};

pub const RebaseError = Error;

pub const failing: Reader = .{
    .vtable = &.{
        .stream = failingStream,
        .discard = failingDiscard,
    },
    .buffer = &.{},
    .seek = 0,
    .end = 0,
};

/// This is generally safe to `@constCast` because it has an empty buffer, so
/// there is not really a way to accidentally attempt mutation of these fields.
pub const ending_instance: Reader = .fixed(&.{});
pub const ending: *Reader = @constCast(&ending_instance);

pub fn limited(r: *Reader, limit: Limit, buffer: []u8) Limited {
    return .init(r, limit, buffer);
}

/// Constructs a `Reader` such that it will read from `buffer` and then end.
pub fn fixed(buffer: []const u8) Reader {
    return .{
        .vtable = &.{
            .stream = endingStream,
            .discard = endingDiscard,
            .readVec = endingReadVec,
            .rebase = endingRebase,
        },
        // This cast is safe because all potential writes to it will instead
        // return `error.EndOfStream`.
        .buffer = @constCast(buffer),
        .end = buffer.len,
        .seek = 0,
    };
}

pub fn stream(r: *Reader, w: *Writer, limit: Limit) StreamError!usize {
    const buffer = limit.slice(r.buffer[r.seek..r.end]);
    if (buffer.len > 0) {
        @branchHint(.likely);
        const n = try w.write(buffer);
        r.seek += n;
        return n;
    }
    const n = try r.vtable.stream(r, w, limit);
    assert(n <= @backingInt(limit));
    return n;
}

pub fn discard(r: *Reader, limit: Limit) Error!usize {
    const buffered_len = r.end - r.seek;
    const remaining: Limit = if (limit.toInt()) |n| l: {
        if (buffered_len >= n) {
            r.seek += n;
            return n;
        }
        break :l .limited(n - buffered_len);
    } else .unlimited;
    r.seek = r.end;
    const n = try r.vtable.discard(r, remaining);
    assert(n <= @backingInt(remaining));
    return buffered_len + n;
}

pub fn defaultDiscard(r: *Reader, limit: Limit) Error!usize {
    assert(r.seek == r.end);
    r.seek = 0;
    r.end = 0;
    var d: Writer.Discarding = .init(r.buffer);
    var n = r.stream(&d.writer, limit) catch |err| switch (err) {
        error.WriteFailed => unreachable,
        error.ReadFailed, error.EndOfStream => |e| return e,
    };
    // If `stream` wrote to `r.buffer` without going through the writer,
    // we need to discard as much of the buffered data as possible.
    const remaining = @backingInt(limit) - n;
    const buffered_n_to_discard = @min(remaining, r.end - r.seek);
    n += buffered_n_to_discard;
    r.seek += buffered_n_to_discard;
    assert(n <= @backingInt(limit));
    return n;
}

/// "Pump" exactly `n` bytes from the reader to the writer.
pub fn streamExact(r: *Reader, w: *Writer, n: usize) StreamError!void {
    var remaining = n;
    while (remaining != 0) remaining -= try r.stream(w, .limited(remaining));
}

/// "Pump" exactly `n` bytes from the reader to the writer.
pub fn streamExact64(r: *Reader, w: *Writer, n: u64) StreamError!void {
    var remaining = n;
    while (remaining != 0) remaining -= try r.stream(w, .limited64(remaining));
}

/// "Pump" exactly `n` bytes from the reader to the writer.
///
/// On success, at least `preserve_len` bytes will remain buffered if there are
/// enough buffered bytes to do so.
/// The amount buffered by the writer after the call will only be less than
/// `preserve_len` if `w.end + n` is less than `preserve_len` before the call.
/// The intentionally preserved bytes will include up to `preserve_len -| n` bytes from
/// the previously buffered bytes, plus `@min(n, preserve_len)` of the newly
/// "pumped" bytes.
///
/// Asserts `Writer.buffer` capacity is at least `preserve_len`.
/// `n` can be greater than the `Writer.buffer` capacity.
pub fn streamExactPreserve(r: *Reader, w: *Writer, preserve_len: usize, n: usize) StreamError!void {
    if (w.end + n <= w.buffer.len) {
        @branchHint(.likely);
        return streamExact(r, w, n);
    }
    // If `n` is large, we can ignore `preserve_len` up to a point.
    var remaining = n;
    while (remaining > preserve_len) {
        assert(remaining != 0);
        remaining -= try r.stream(w, .limited(remaining - preserve_len));
        if (w.end + remaining <= w.buffer.len) return streamExact(r, w, remaining);
    }
    // Offset the amount preserved by the amount we have left to stream
    // since the remaining bytes are always going to be part of that
    // preservation.
    try w.rebase(preserve_len -| remaining, remaining);
    return streamExact(r, w, remaining);
}

/// "Pump" data from the reader to the writer, handling `error.EndOfStream` as
/// a success case.
///
/// Returns total number of bytes written to `w`.
pub fn streamRemaining(r: *Reader, w: *Writer) StreamRemainingError!usize {
    var offset: usize = 0;
    while (true) {
        offset += r.stream(w, .unlimited) catch |err| switch (err) {
            error.EndOfStream => return offset,
            else => |e| return e,
        };
    }
}

/// Consumes the stream until the end, ignoring all the data, returning the
/// number of bytes discarded.
pub fn discardRemaining(r: *Reader) ShortError!usize {
    var offset: usize = r.end - r.seek;
    r.seek = r.end;
    while (true) {
        offset += r.vtable.discard(r, .unlimited) catch |err| switch (err) {
            error.EndOfStream => return offset,
            else => |e| return e,
        };
    }
}

pub const LimitedAllocError = Allocator.Error || ShortError || error{StreamTooLong};

/// Transfers all bytes from the current position to the end of the stream, up
/// to `limit`, returning them as a caller-owned allocated slice.
///
/// If `limit` is exceeded, `error.StreamTooLong` is returned instead.
/// In such case, the next byte that would be read will be one byte past the
/// first one to exceed `limit`, and all preceeding bytes have been discarded.
///
/// See also:
/// * `appendRemaining`
pub fn allocRemaining(r: *Reader, gpa: Allocator, limit: Limit) LimitedAllocError![]u8 {
    var buffer: ArrayList(u8) = .empty;
    defer buffer.deinit(gpa);

    try appendRemaining(r, gpa, &buffer, switch (limit) {
        .unlimited => limit,
        .nothing, _ => .limited(@backingInt(limit) + 1),
    });
    return buffer.toOwnedSlice(gpa);
}

pub fn allocRemainingAlignedSentinel(
    r: *Reader,
    gpa: Allocator,
    limit: Limit,
    comptime alignment: std.mem.Alignment,
    comptime sentinel: ?u8,
) LimitedAllocError!(if (sentinel) |s| [:s]align(alignment.toByteUnits()) u8 else []align(alignment.toByteUnits()) u8) {
    var buffer: std.array_list.Aligned(u8, alignment) = .empty;
    defer buffer.deinit(gpa);
    try appendRemainingAligned(r, gpa, alignment, &buffer, limit);
    if (sentinel) |s| {
        return buffer.toOwnedSliceSentinel(gpa, s);
    } else {
        return buffer.toOwnedSlice(gpa);
    }
}

pub const AppendExactError = Allocator.Error || Error;

/// Transfers exactly `n` bytes from the reader to the `ArrayList`.
///
/// See also:
/// * `appendRemaining`
pub fn appendExact(
    r: *Reader,
    gpa: Allocator,
    list: *ArrayList(u8),
    n: usize,
) AppendExactError!void {
    try list.ensureUnusedCapacity(gpa, n);
    var a = std.Io.Writer.Allocating.fromArrayList(gpa, list);
    defer list.* = a.toArrayList();
    streamExact(r, &a.writer, n) catch |err| switch (err) {
        error.ReadFailed, error.EndOfStream => |e| return e,
        error.WriteFailed => unreachable,
    };
}

/// Transfers all bytes from the current position to the end of the stream, up
/// to `limit`, appending them to `list`.
///
/// If `limit` is reached or exceeded, `error.StreamTooLong` is returned
/// instead. In such case, the next byte that would be read will be the first
/// one to exceed `limit`, and all preceeding bytes have been appended to
/// `list`.
///
/// See also:
/// * `allocRemaining`
pub fn appendRemaining(
    r: *Reader,
    gpa: Allocator,
    list: *ArrayList(u8),
    limit: Limit,
) LimitedAllocError!void {
    return appendRemainingAligned(r, gpa, .of(u8), list, limit);
}

/// Transfers all bytes from the current position to the end of the stream, up
/// to `limit`, appending them to `list`.
///
/// If `limit` is reached or exceeded, `error.StreamTooLong` is returned
/// instead. In such case, the next byte that would be read will be the first
/// one to exceed `limit`, and all preceeding bytes have been appended to
/// `list`.
///
/// See also:
/// * `appendRemaining`
/// * `allocRemainingAligned`
pub fn appendRemainingAligned(
    r: *Reader,
    gpa: Allocator,
    comptime alignment: std.mem.Alignment,
    list: *std.array_list.Aligned(u8, alignment),
    limit: Limit,
) LimitedAllocError!void {
    var a = std.Io.Writer.Allocating.fromArrayListAligned(gpa, alignment, list);
    defer list.* = a.toArrayListAligned(alignment);

    var remaining = limit;
    while (remaining != .nothing) {
        const n = stream(r, &a.writer, remaining) catch |err| switch (err) {
            error.EndOfStream => return,
            error.WriteFailed => return error.OutOfMemory,
            error.ReadFailed => |e| return e,
        };
        remaining = remaining.subtract(n).?;
    }
    return error.StreamTooLong;
}

pub const UnlimitedAllocError = Allocator.Error || ShortError;

pub fn appendRemainingUnlimited(r: *Reader, gpa: Allocator, list: *ArrayList(u8)) UnlimitedAllocError!void {
    list.pointer_stability.assertUnlocked();
    var a: std.Io.Writer.Allocating = .initOwnedSlice(gpa, list.allocatedSlice());
    a.writer.end = list.items.len;
    list.* = .empty;
    defer {
        list.* = .{
            .items = a.writer.buffer[0..a.writer.end],
            .capacity = a.writer.buffer.len,
            .pointer_stability = .{},
        };
    }
    _ = streamRemaining(r, &a.writer) catch |err| switch (err) {
        error.WriteFailed => return error.OutOfMemory,
        error.ReadFailed => |e| return e,
    };
}

/// Writes bytes from the internally tracked stream position to `data`.
///
/// Returns the number of bytes written, which will be at minimum `0` and
/// at most the sum of each data slice length. The number of bytes read,
/// including zero, does not indicate end of stream.
///
/// The reader's internal logical seek position moves forward in accordance
/// with the number of bytes returned from this function.
pub fn readVec(r: *Reader, data: [][]u8) Error!usize {
    var seek = r.seek;
    for (data, 0..) |buf, i| {
        const contents = r.buffer[seek..r.end];
        const copy_len = @min(contents.len, buf.len);
        @memcpy(buf[0..copy_len], contents[0..copy_len]);
        seek += copy_len;
        if (buf.len - copy_len == 0) continue;

        // All of `buffer` has been copied to `data`.
        const n = seek - r.seek;
        r.seek = seek;
        data[i] = buf[copy_len..];
        defer data[i] = buf;
        return n + (r.vtable.readVec(r, data[i..]) catch |err| switch (err) {
            error.EndOfStream => if (n == 0) return error.EndOfStream else 0,
            error.ReadFailed => |e| return e,
        });
    }
    const n = seek - r.seek;
    r.seek = seek;
    return n;
}

/// Writes to `Reader.buffer` or `data`, whichever has larger capacity.
pub fn defaultReadVec(r: *Reader, data: [][]u8) Error!usize {
    const first = data[0];
    if (first.len >= r.buffer.len - r.end) {
        var writer: Writer = .{
            .buffer = first,
            .end = 0,
            .vtable = &.{ .drain = Writer.fixedDrain },
        };
        const limit: Limit = .limited(writer.buffer.len - writer.end);
        return r.vtable.stream(r, &writer, limit) catch |err| switch (err) {
            error.WriteFailed => unreachable,
            else => |e| return e,
        };
    }
    var writer: Writer = .{
        .buffer = r.buffer,
        .end = r.end,
        .vtable = &.{ .drain = Writer.fixedDrain },
    };
    const limit: Limit = .limited(writer.buffer.len - writer.end);
    const n = r.vtable.stream(r, &writer, limit) catch |err| switch (err) {
        error.WriteFailed => unreachable,
        else => |e| return e,
    };
    r.end += n;
    return 0;
}

pub fn buffered(r: *Reader) []u8 {
    return r.buffer[r.seek..r.end];
}

pub fn bufferedLen(r: *const Reader) usize {
    return r.end - r.seek;
}

pub fn hashed(r: *Reader, hasher: anytype, buffer: []u8) Hashed(@TypeOf(hasher)) {
    return .init(r, hasher, buffer);
}

pub fn readVecAll(r: *Reader, data: [][]u8) Error!void {
    var index: usize = 0;
    var truncate: usize = 0;
    while (index < data.len) {
        {
            const untruncated = data[index];
            data[index] = untruncated[truncate..];
            defer data[index] = untruncated;
            truncate += try r.readVec(data[index..]);
        }
        while (index < data.len and truncate >= data[index].len) {
            truncate -= data[index].len;
            index += 1;
        }
    }
}

/// Returns the next `n` bytes from the stream, filling the buffer as
/// necessary.
///
/// Invalidates previously returned values from `peek`.
///
/// Asserts that the `Reader` was initialized with a buffer capacity at
/// least as big as `n`.
///
/// If there are fewer than `n` bytes left in the stream, `error.EndOfStream`
/// is returned instead.
///
/// See also:
/// * `toss`
pub fn peek(r: *Reader, n: usize) Error![]u8 {
    try r.fill(n);
    return r.buffer[r.seek..][0..n];
}

/// Returns all the next buffered bytes, after filling the buffer to ensure it
/// contains at least `n` bytes.
///
/// Invalidates previously returned values from `peek` and `peekGreedy`.
///
/// Asserts that the `Reader` was initialized with a buffer capacity at
/// least as big as `n`.
///
/// If there are fewer than `n` bytes left in the stream, `error.EndOfStream`
/// is returned instead.
///
/// See also:
/// * `peek`
/// * `toss`
pub fn peekGreedy(r: *Reader, n: usize) Error![]u8 {
    try r.fill(n);
    return r.buffer[r.seek..r.end];
}

/// Skips the next `n` bytes from the stream, advancing the seek position. This
/// is typically and safely used after `peek`.
///
/// Asserts that the number of bytes buffered is at least as many as `n`.
///
/// The "tossed" memory remains alive until a "peek" operation occurs.
///
/// See also:
/// * `peek`.
/// * `discard`.
pub fn toss(r: *Reader, n: usize) void {
    r.seek += n;
    assert(r.seek <= r.end);
}

/// Equivalent to `toss(r.bufferedLen())`.
pub fn tossBuffered(r: *Reader) void {
    r.seek = r.end;
}

/// Equivalent to `peek` followed by `toss`.
///
/// The data returned is invalidated by the next call to `take`, `peek`,
/// `fill`, and functions with those prefixes.
pub fn take(r: *Reader, n: usize) Error![]u8 {
    const result = try r.peek(n);
    r.toss(n);
    return result;
}

/// Returns the next `n` bytes from the stream as an array, filling the buffer
/// as necessary and advancing the seek position `n` bytes.
///
/// Asserts that the `Reader` was initialized with a buffer capacity at
/// least as big as `n`.
///
/// If there are fewer than `n` bytes left in the stream, `error.EndOfStream`
/// is returned instead.
///
/// See also:
/// * `take`
pub fn takeArray(r: *Reader, comptime n: usize) Error!*[n]u8 {
    return (try r.take(n))[0..n];
}

/// Returns the next `n` bytes from the stream as an array, filling the buffer
/// as necessary, without advancing the seek position.
///
/// Asserts that the `Reader` was initialized with a buffer capacity at
/// least as big as `n`.
///
/// If there are fewer than `n` bytes left in the stream, `error.EndOfStream`
/// is returned instead.
///
/// See also:
/// * `peek`
/// * `takeArray`
pub fn peekArray(r: *Reader, comptime n: usize) Error!*[n]u8 {
    return (try r.peek(n))[0..n];
}

/// Skips the next `n` bytes from the stream, advancing the seek position.
///
/// Unlike `toss` which is infallible, in this function `n` can be any amount.
///
/// Returns `error.EndOfStream` if fewer than `n` bytes could be discarded.
///
/// See also:
/// * `toss`
/// * `discardRemaining`
/// * `discardShort`
/// * `discard`
pub fn discardAll(r: *Reader, n: usize) Error!void {
    if ((try r.discardShort(n)) != n) return error.EndOfStream;
}

pub fn discardAll64(r: *Reader, n: u64) Error!void {
    var remaining: u64 = n;
    while (remaining > 0) {
        const limited_remaining = std.math.cast(usize, remaining) orelse std.math.maxInt(usize);
        try discardAll(r, limited_remaining);
        remaining -= limited_remaining;
    }
}

/// Skips the next `n` bytes from the stream, advancing the seek position.
///
/// Unlike `toss` which is infallible, in this function `n` can be any amount.
///
/// Returns the number of bytes discarded, which is less than `n` if and only
/// if the stream reached the end.
///
/// See also:
/// * `discardAll`
/// * `discardRemaining`
/// * `discard`
pub fn discardShort(r: *Reader, n: usize) ShortError!usize {
    const proposed_seek = r.seek + n;
    if (proposed_seek <= r.end) {
        @branchHint(.likely);
        r.seek = proposed_seek;
        return n;
    }
    var remaining = n - (r.end - r.seek);
    r.seek = r.end;
    while (true) {
        const discard_len = r.vtable.discard(r, .limited(remaining)) catch |err| switch (err) {
            error.EndOfStream => return n - remaining,
            error.ReadFailed => |e| return e,
        };
        remaining -= discard_len;
        if (remaining == 0) return n;
    }
}

/// Fill `buffer` with the next `buffer.len` bytes from the stream, advancing
/// the seek position.
///
/// Invalidates previously returned values from `peek`.
///
/// If the provided buffer cannot be filled completely, `error.EndOfStream` is
/// returned instead.
///
/// See also:
/// * `peek`
/// * `readSliceShort`
pub fn readSliceAll(r: *Reader, buffer: []u8) Error!void {
    const n = try readSliceShort(r, buffer);
    if (n != buffer.len) return error.EndOfStream;
}

/// Fill `buffer` with the next `buffer.len` bytes from the stream, advancing
/// the seek position.
///
/// Invalidates previously returned values from `peek`.
///
/// Returns the number of bytes read, which is less than `buffer.len` if and
/// only if the stream reached the end.
///
/// See also:
/// * `readSliceAll`
pub fn readSliceShort(r: *Reader, buffer: []u8) ShortError!usize {
    const contents = r.buffer[r.seek..r.end];
    const copy_len = @min(buffer.len, contents.len);
    @memcpy(buffer[0..copy_len], contents[0..copy_len]);
    r.seek += copy_len;
    if (buffer.len - copy_len == 0) {
        @branchHint(.likely);
        return buffer.len;
    }
    var i: usize = copy_len;
    var data: [1][]u8 = undefined;
    while (true) {
        data[0] = buffer[i..];
        i += readVec(r, &data) catch |err| switch (err) {
            error.EndOfStream => return i,
            error.ReadFailed => |e| return e,
        };
        if (buffer.len - i == 0) return buffer.len;
    }
}

/// Fill `buffer` with the next `buffer.len` bytes from the stream, advancing
/// the seek position.
///
/// Invalidates previously returned values from `peek`.
///
/// If the provided buffer cannot be filled completely, `error.EndOfStream` is
/// returned instead.
///
/// The function is inline to avoid the dead code in case `endian` is
/// comptime-known and matches host endianness.
///
/// See also:
/// * `readSliceAll`
/// * `readSliceEndianAlloc`
pub inline fn readSliceEndian(
    r: *Reader,
    comptime Elem: type,
    buffer: []Elem,
    endian: std.builtin.Endian,
) Error!void {
    try readSliceAll(r, @ptrCast(buffer));
    if (native_endian != endian) std.mem.byteSwapAllElements(Elem, buffer);
}

pub const ReadAllocError = Error || Allocator.Error;

/// The function is inline to avoid the dead code in case `endian` is
/// comptime-known and matches host endianness.
pub inline fn readSliceEndianAlloc(
    r: *Reader,
    allocator: Allocator,
    comptime Elem: type,
    len: usize,
    endian: std.builtin.Endian,
) ReadAllocError![]Elem {
    const dest = try allocator.alloc(Elem, len);
    errdefer allocator.free(dest);
    try r.readSliceEndian(Elem, dest, endian);
    return dest;
}

/// Deprecated; use readAllocAll. to be removed after 0.17.
pub const readAlloc = readAllocAll;

/// Shortcut for calling `readSliceAll` with a buffer provided by `allocator`.
pub fn readAllocAll(r: *Reader, allocator: Allocator, len: usize) ReadAllocError![]u8 {
    const dest = try allocator.alloc(u8, len);
    errdefer allocator.free(dest);
    try readSliceAll(r, dest);
    return dest;
}

/// Shortcut for calling `readSliceShort` with a buffer provided by `allocator`,
/// shrinking allocation if stream reached the end.
pub fn readAllocShort(r: *Reader, allocator: Allocator, len: usize) ReadAllocError![]u8 {
    const dest = try allocator.alloc(u8, len);
    errdefer allocator.free(dest);
    const n = try readSliceShort(r, dest);
    if (n == dest.len) return dest;
    return try allocator.realloc(dest, n);
}

pub const DelimiterError = error{
    /// See the `Reader` implementation for detailed diagnostics.
    ReadFailed,
    /// For "inclusive" functions, stream ended before the delimiter was found.
    /// For "exclusive" functions, stream ended and there are no more bytes to
    /// return.
    EndOfStream,
    /// The delimiter was not found within a number of bytes matching the
    /// capacity of the `Reader`.
    StreamTooLong,
};

/// Returns a slice of the next bytes of buffered data from the stream until
/// `sentinel` is found, advancing the seek position past the sentinel.
///
/// Returned slice has a sentinel.
///
/// Invalidates previously returned values from `peek`.
///
/// See also:
/// * `peekSentinel`
/// * `takeDelimiterExclusive`
/// * `takeDelimiterInclusive`
pub fn takeSentinel(r: *Reader, comptime sentinel: u8) DelimiterError![:sentinel]u8 {
    const result = try r.peekSentinel(sentinel);
    r.toss(result.len + 1);
    return result;
}

/// Returns a slice of the next bytes of buffered data from the stream until
/// `sentinel` is found, without advancing the seek position.
///
/// Returned slice has a sentinel; end of stream does not count as a delimiter.
///
/// Invalidates previously returned values from `peek`.
///
/// See also:
/// * `takeSentinel`
/// * `peekDelimiterExclusive`
/// * `peekDelimiterInclusive`
pub fn peekSentinel(r: *Reader, comptime sentinel: u8) DelimiterError![:sentinel]u8 {
    const result = try r.peekDelimiterInclusive(sentinel);
    return result[0 .. result.len - 1 :sentinel];
}

/// Returns a slice of the next bytes of buffered data from the stream until
/// `delimiter` is found, advancing the seek position past the delimiter.
///
/// Returned slice includes the delimiter as the last byte.
///
/// Invalidates previously returned values from `peek`.
///
/// See also:
/// * `takeSentinel`
/// * `takeDelimiterExclusive`
/// * `peekDelimiterInclusive`
pub fn takeDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
    const result = try r.peekDelimiterInclusive(delimiter);
    r.toss(result.len);
    return result;
}

/// Returns a slice of the next bytes of buffered data from the stream until
/// `delimiter` is found, without advancing the seek position.
///
/// Returned slice includes the delimiter as the last byte.
///
/// Invalidates previously returned values from `peek`.
///
/// See also:
/// * `peekSentinel`
/// * `peekDelimiterExclusive`
/// * `takeDelimiterInclusive`
pub fn peekDelimiterInclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
    {
        const contents = r.buffer[0..r.end];
        const seek = r.seek;
        if (std.mem.findScalarPos(u8, contents, seek, delimiter)) |end| {
            @branchHint(.likely);
            return contents[seek .. end + 1];
        }
    }
    while (true) {
        const content_len = r.end - r.seek;
        if (r.buffer.len - content_len == 0) break;
        try fillMore(r);
        const seek = r.seek;
        const contents = r.buffer[0..r.end];
        if (std.mem.findScalarPos(u8, contents, seek + content_len, delimiter)) |end| {
            return contents[seek .. end + 1];
        }
    }
    // It might or might not be end of stream. There is no more buffer space
    // left to disambiguate. If `StreamTooLong` was added to `RebaseError` then
    // this logic could be replaced by removing the exit condition from the
    // above while loop. That error code would represent when `buffer` capacity
    // is too small for an operation, replacing the current use of asserts.
    var failing_writer = Writer.failing;
    while (r.vtable.stream(r, &failing_writer, .limited(1))) |n| {
        assert(n == 0);
    } else |err| switch (err) {
        error.WriteFailed => return error.StreamTooLong,
        error.ReadFailed => |e| return e,
        error.EndOfStream => |e| return e,
    }
}

/// Returns a slice of the next bytes of buffered data from the stream until
/// `delimiter` is found, advancing the seek position up to (but not past)
/// the delimiter.
///
/// Returned slice excludes the delimiter. End-of-stream is treated equivalent
/// to a delimiter, unless it would result in a length 0 return value, in which
/// case `error.EndOfStream` is returned instead.
///
/// If the delimiter is not found within a number of bytes matching the
/// capacity of this `Reader`, `error.StreamTooLong` is returned. In
/// such case, the stream state is unmodified as if this function was never
/// called.
///
/// Invalidates previously returned values from `peek`.
///
/// See also:
/// * `takeDelimiter`
/// * `takeDelimiterInclusive`
/// * `peekDelimiterExclusive`
pub fn takeDelimiterExclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
    const result = try r.peekDelimiterExclusive(delimiter);
    r.toss(result.len);
    return result;
}

/// Returns a slice of the next bytes of buffered data from the stream until
/// `delimiter` is found, advancing the seek position past the delimiter.
///
/// Returned slice excludes the delimiter. End-of-stream is treated equivalent
/// to a delimiter, unless it would result in a length 0 return value, in which
/// case `null` is returned instead.
///
/// If the delimiter is not found within a number of bytes matching the
/// capacity of this `Reader`, `error.StreamTooLong` is returned. In
/// such case, the stream state is unmodified as if this function was never
/// called.
///
/// Invalidates previously returned values from `peek`.
///
/// See also:
/// * `takeDelimiterInclusive`
/// * `takeDelimiterExclusive`
pub fn takeDelimiter(r: *Reader, delimiter: u8) error{ ReadFailed, StreamTooLong }!?[]u8 {
    const inclusive = r.peekDelimiterInclusive(delimiter) catch |err| switch (err) {
        error.EndOfStream => {
            const remaining = r.buffer[r.seek..r.end];
            if (remaining.len == 0) return null;
            r.toss(remaining.len);
            return remaining;
        },
        else => |e| return e,
    };
    r.toss(inclusive.len);
    return inclusive[0 .. inclusive.len - 1];
}

/// Returns a slice of the next bytes of buffered data from the stream until
/// `delimiter` is found, without advancing the seek position.
///
/// Returned slice excludes the delimiter. End-of-stream is treated equivalent
/// to a delimiter, unless it would result in a length 0 return value, in which
/// case `error.EndOfStream` is returned instead.
///
/// If the delimiter is not found within a number of bytes matching the
/// capacity of this `Reader`, `error.StreamTooLong` is returned. In
/// such case, the stream state is unmodified as if this function was never
/// called.
///
/// Invalidates previously returned values from `peek`.
///
/// See also:
/// * `peekDelimiterInclusive`
/// * `takeDelimiterExclusive`
pub fn peekDelimiterExclusive(r: *Reader, delimiter: u8) DelimiterError![]u8 {
    const result = r.peekDelimiterInclusive(delimiter) catch |err| switch (err) {
        error.EndOfStream => {
            const remaining = r.buffer[r.seek..r.end];
            if (remaining.len == 0) return error.EndOfStream;
            return remaining;
        },
        else => |e| return e,
    };
    return result[0 .. result.len - 1];
}

/// Appends to `w` contents by reading from the stream until `delimiter` is
/// found. Does not write the delimiter itself.
///
/// Does not discard the delimiter from the `Reader`.
///
/// Returns number of bytes streamed, which may be zero, or error.EndOfStream
/// if the delimiter was not found.
///
/// Asserts buffer capacity of at least one. This function performs better with
/// larger buffers.
///
/// See also:
/// * `streamDelimiterEnding`
/// * `streamDelimiterLimit`
pub fn streamDelimiter(r: *Reader, w: *Writer, delimiter: u8) StreamError!usize {
    const n = streamDelimiterLimit(r, w, delimiter, .unlimited) catch |err| switch (err) {
        error.StreamTooLong => unreachable, // unlimited is passed
        else => |e| return e,
    };
    if (r.seek == r.end) return error.EndOfStream;
    return n;
}

/// Appends to `w` contents by reading from the stream until `delimiter` is found.
/// Does not write the delimiter itself.
///
/// Returns number of bytes streamed, which may be zero. If the stream reaches
/// the end, the reader buffer will be empty when this function returns.
/// Otherwise, it will have at least one byte buffered, starting with the
/// delimiter.
///
/// Asserts buffer capacity of at least one. This function performs better with
/// larger buffers.
///
/// See also:
/// * `streamDelimiter`
/// * `streamDelimiterLimit`
pub fn streamDelimiterEnding(
    r: *Reader,
    w: *Writer,
    delimiter: u8,
) StreamRemainingError!usize {
    return streamDelimiterLimit(r, w, delimiter, .unlimited) catch |err| switch (err) {
        error.StreamTooLong => unreachable, // unlimited is passed
        else => |e| return e,
    };
}

pub const StreamDelimiterLimitError = error{
    ReadFailed,
    WriteFailed,
    /// The delimiter was not found within the limit.
    StreamTooLong,
};

/// Appends to `w` contents by reading from the stream until `delimiter` is found.
/// Does not write the delimiter itself.
///
/// Does not discard the delimiter from the `Reader`.
///
/// Returns number of bytes streamed, which may be zero. End of stream can be
/// detected by checking if the next byte in the stream is the delimiter.
///
/// Asserts buffer capacity of at least one. This function performs better with
/// larger buffers.
pub fn streamDelimiterLimit(
    r: *Reader,
    w: *Writer,
    delimiter: u8,
    limit: Limit,
) StreamDelimiterLimitError!usize {
    var remaining = @backingInt(limit);
    while (remaining != 0) {
        const available = Limit.limited(remaining).slice(r.peekGreedy(1) catch |err| switch (err) {
            error.ReadFailed => |e| return e,
            error.EndOfStream => return @backingInt(limit) - remaining,
        });
        if (std.mem.findScalar(u8, available, delimiter)) |delimiter_index| {
            try w.writeAll(available[0..delimiter_index]);
            r.toss(delimiter_index);
            remaining -= delimiter_index;
            return @backingInt(limit) - remaining;
        }
        try w.writeAll(available);
        r.toss(available.len);
        remaining -= available.len;
    }
    return error.StreamTooLong;
}

/// Reads from the stream until specified byte is found, discarding all data,
/// including the delimiter.
///
/// Returns number of bytes discarded, or `error.EndOfStream` if the delimiter
/// is not found.
///
/// See also:
/// * `discardDelimiterExclusive`
/// * `discardDelimiterLimit`
pub fn discardDelimiterInclusive(r: *Reader, delimiter: u8) Error!usize {
    const n = discardDelimiterLimit(r, delimiter, .unlimited) catch |err| switch (err) {
        error.StreamTooLong => unreachable, // unlimited is passed
        else => |e| return e,
    };
    if (r.seek == r.end) return error.EndOfStream;
    assert(r.buffer[r.seek] == delimiter);
    toss(r, 1);
    return n + 1;
}

/// Reads from the stream until specified byte is found, discarding all data,
/// excluding the delimiter.
///
/// Returns the number of bytes discarded.
///
/// Succeeds if stream ends before delimiter found. End of stream can be
/// detected by checking if the delimiter is buffered.
///
/// See also:
/// * `discardDelimiterInclusive`
/// * `discardDelimiterLimit`
pub fn discardDelimiterExclusive(r: *Reader, delimiter: u8) ShortError!usize {
    return discardDelimiterLimit(r, delimiter, .unlimited) catch |err| switch (err) {
        error.StreamTooLong => unreachable, // unlimited is passed
        else => |e| return e,
    };
}

pub const DiscardDelimiterLimitError = error{
    ReadFailed,
    /// The delimiter was not found within the limit.
    StreamTooLong,
};

/// Reads from the stream until specified byte is found, discarding all data,
/// excluding the delimiter.
///
/// Returns the number of bytes discarded.
///
/// Succeeds if stream ends before delimiter found. End of stream can be
/// detected by checking if the delimiter is buffered.
pub fn discardDelimiterLimit(r: *Reader, delimiter: u8, limit: Limit) DiscardDelimiterLimitError!usize {
    var remaining = @backingInt(limit);
    while (remaining != 0) {
        const available = Limit.limited(remaining).slice(r.peekGreedy(1) catch |err| switch (err) {
            error.ReadFailed => |e| return e,
            error.EndOfStream => return @backingInt(limit) - remaining,
        });
        if (std.mem.findScalar(u8, available, delimiter)) |delimiter_index| {
            r.toss(delimiter_index);
            remaining -= delimiter_index;
            return @backingInt(limit) - remaining;
        }
        r.toss(available.len);
        remaining -= available.len;
    }
    return error.StreamTooLong;
}

/// Fills the buffer such that it contains at least `n` bytes, without
/// advancing the seek position.
///
/// Returns `error.EndOfStream` if and only if there are fewer than `n` bytes
/// remaining.
///
/// If the end of stream is not encountered, asserts buffer capacity is at
/// least `n`.
pub fn fill(r: *Reader, n: usize) Error!void {
    if (r.seek + n <= r.end) {
        @branchHint(.likely);
        return;
    }
    return fillUnbuffered(r, n);
}

/// This internal function is separated from `fill` to encourage optimizers to inline `fill`, hence
/// propagating its `@branchHint` to usage sites. If these functions are combined, `fill` is large
/// enough that LLVM is reluctant to inline it, forcing usages of APIs like `takeInt` to go through
/// an expensive runtime function call just to figure out that the data is, in fact, already in the
/// buffer.
///
/// Missing this optimization can result in wall-clock time for the most affected benchmarks
/// increasing by a factor of 5 or more.
fn fillUnbuffered(r: *Reader, n: usize) Error!void {
    try rebase(r, n);
    var bufs: [1][]u8 = .{""};
    while (r.end < r.seek + n) _ = try r.vtable.readVec(r, &bufs);
}

/// Without advancing the seek position, does exactly one underlying read, filling the buffer as
/// much as possible. This may result in zero bytes added to the buffer, which is not an end of
/// stream condition. End of stream is communicated via returning `error.EndOfStream`.
///
/// Asserts buffer capacity is at least 1.
pub fn fillMore(r: *Reader) Error!void {
    try rebase(r, r.end - r.seek + 1);
    var bufs: [1][]u8 = .{""};
    _ = try r.vtable.readVec(r, &bufs);
}

/// Returns the next byte from the stream or returns `error.EndOfStream`.
///
/// Does not advance the seek position.
///
/// Asserts the buffer capacity is nonzero.
pub fn peekByte(r: *Reader) Error!u8 {
    const buffer = r.buffer[0..r.end];
    const seek = r.seek;
    if (seek < buffer.len) {
        @branchHint(.likely);
        return buffer[seek];
    }
    try fill(r, 1);
    return r.buffer[r.seek];
}

/// Reads 1 byte from the stream or returns `error.EndOfStream`.
///
/// Asserts the buffer capacity is nonzero.
pub fn takeByte(r: *Reader) Error!u8 {
    const result = try peekByte(r);
    r.seek += 1;
    return result;
}

/// Same as `takeByte` except the returned byte is signed.
pub fn takeByteSigned(r: *Reader) Error!i8 {
    return @bitCast(try r.takeByte());
}

/// Asserts the buffer was initialized with a capacity at least `@bitSizeOf(T) / 8`.
pub inline fn takeInt(r: *Reader, comptime T: type, endian: std.builtin.Endian) Error!T {
    const n = @divExact(@typeInfo(T).int.bits, 8);
    return std.mem.readInt(T, try r.takeArray(n), endian);
}

/// Asserts the buffer was initialized with a capacity at least `@bitSizeOf(T) / 8`.
pub inline fn peekInt(r: *Reader, comptime T: type, endian: std.builtin.Endian) Error!T {
    const n = @divExact(@typeInfo(T).int.bits, 8);
    return std.mem.readInt(T, try r.peekArray(n), endian);
}

/// Asserts the buffer was initialized with a capacity at least `n`.
pub fn takeVarInt(r: *Reader, comptime Int: type, endian: std.builtin.Endian, n: usize) Error!Int {
    assert(n <= @sizeOf(Int));
    return std.mem.readVarInt(Int, try r.take(n), endian);
}

/// Obtains an unaligned pointer to the beginning of the stream, reinterpreted
/// as a pointer to the provided type, advancing the seek position.
///
/// Asserts the buffer was initialized with a capacity at least `@sizeOf(T)`.
///
/// See also:
/// * `peekStructPointer`
/// * `takeStruct`
pub fn takeStructPointer(r: *Reader, comptime T: type) Error!*align(1) T {
    // Only extern and packed structs have defined in-memory layout.
    comptime assert(@typeInfo(T).@"struct".layout != .auto);
    return @ptrCast(try r.takeArray(@sizeOf(T)));
}

/// Obtains an unaligned pointer to the beginning of the stream, reinterpreted
/// as a pointer to the provided type, without advancing the seek position.
///
/// Asserts the buffer was initialized with a capacity at least `@sizeOf(T)`.
///
/// See also:
/// * `takeStructPointer`
/// * `peekStruct`
pub fn peekStructPointer(r: *Reader, comptime T: type) Error!*align(1) T {
    // Only extern and packed structs have defined in-memory layout.
    comptime assert(@typeInfo(T).@"struct".layout != .auto);
    return @ptrCast(try r.peekArray(@sizeOf(T)));
}

/// This function is inline to avoid referencing `std.mem.byteSwapAllFields`
/// when `endian` is comptime-known and matches the host endianness.
///
/// See also:
/// * `takeStructPointer`
/// * `peekStruct`
pub inline fn takeStruct(r: *Reader, comptime T: type, endian: std.builtin.Endian) Error!T {
    switch (@typeInfo(T)) {
        .@"struct" => |info| switch (info.layout) {
            .auto => @compileError("ill-defined memory layout"),
            .@"extern" => {
                var res: T = undefined;
                try r.readSliceEndian(T, (&res)[0..1], endian);
                return res;
            },
            .@"packed" => {
                return @bitCast(try takeInt(r, info.backing_integer.?, endian));
            },
        },
        else => @compileError("not a struct"),
    }
}

/// Asserts the buffer was initialized with a capacity at least `@sizeOf(T)`.
///
/// This function is inline to avoid referencing `std.mem.byteSwapAllFields`
/// when `endian` is comptime-known and matches the host endianness.
///
/// See also:
/// * `takeStruct`
/// * `peekStructPointer`
pub inline fn peekStruct(r: *Reader, comptime T: type, endian: std.builtin.Endian) Error!T {
    switch (@typeInfo(T)) {
        .@"struct" => |info| switch (info.layout) {
            .auto => @compileError("ill-defined memory layout"),
            .@"extern" => {
                var res = (try r.peekStructPointer(T)).*;
                if (native_endian != endian) std.mem.byteSwapAllFields(T, &res);
                return res;
            },
            .@"packed" => {
                return @bitCast(try peekInt(r, info.backing_integer.?, endian));
            },
        },
        else => @compileError("not a struct"),
    }
}

pub const TakeEnumError = Error || error{InvalidEnumTag};

/// Reads an integer with the same size as the given enum's tag type. If the
/// integer matches an enum tag, casts the integer to the enum tag and returns
/// it. Otherwise, returns `error.InvalidEnumTag`.
///
/// Asserts the buffer was initialized with a capacity at least `@sizeOf(Enum)`.
pub fn takeEnum(r: *Reader, comptime Enum: type, endian: std.builtin.Endian) TakeEnumError!Enum {
    const Tag = @typeInfo(Enum).@"enum".tag_type;
    const int = try r.takeInt(Tag, endian);
    return std.enums.fromInt(Enum, int) orelse return error.InvalidEnumTag;
}

/// Reads an integer with the same size as the given nonexhaustive enum's tag type.
///
/// Asserts the buffer was initialized with a capacity at least `@sizeOf(Enum)`.
pub fn takeEnumNonexhaustive(r: *Reader, comptime Enum: type, endian: std.builtin.Endian) Error!Enum {
    const info = @typeInfo(Enum).@"enum";
    comptime assert(info.mode != .exhaustive);
    comptime assert(@bitSizeOf(info.tag_type) == @sizeOf(info.tag_type) * 8);
    return takeEnum(r, Enum, endian) catch |err| switch (err) {
        error.InvalidEnumTag => unreachable,
        else => |e| return e,
    };
}

pub const TakeLeb128Error = Error || error{Overflow};

/// Read a single LEB128 value as type T, or `error.Overflow` if the value cannot fit.
pub fn takeLeb128(r: *Reader, comptime T: type) TakeLeb128Error!T {
    const info = switch (@typeInfo(T)) {
        .int => |info| info,
        else => @compileError(@typeName(T) ++ " not supported"),
    };
    const Byte = packed struct { bits: u7, more: bool };

    if (info.bits <= 7) {
        var byte: Byte = undefined;
        const Bits = @Int(info.signedness, 7);

        byte = @bitCast(try r.takeByte());
        const val = std.math.cast(T, @as(Bits, @bitCast(byte.bits))) orelse error.Overflow;

        const allowed_bits: u7 = switch (info.signedness) {
            .unsigned => 0,
            .signed => @bitCast(@as(i7, @bitCast(byte.bits)) >> 6),
        };

        var fits = true;
        while (byte.more) {
            byte = @bitCast(try r.takeByte());

            if (byte.bits != allowed_bits) fits = false;
        }

        return if (fits) blk: {
            @branchHint(.likely);
            break :blk val;
        } else error.Overflow;
    }

    const Unsigned = @Int(.unsigned, info.bits);
    const UInt = std.math.ByteAlignedInt(Unsigned);
    const Int = std.math.ByteAlignedInt(T);

    const uint_bits = @typeInfo(UInt).int.bits;

    var byte: Byte = undefined;
    var val: UInt = 0;
    const max_bytes = @divFloor(info.bits - 1, 7) + 1;
    inline for (0..max_bytes) |iteration| {
        const shift = iteration * 7;

        byte = @bitCast(try r.takeByte());

        const extended: UInt = byte.bits;
        val |= extended << shift;

        const bits_written = shift + 7;

        if (bits_written >= info.bits) {
            const bits_overflowed = bits_written - info.bits;
            const bits_remaining = @mod(info.bits, 7);

            const allowed_bits: u7, var fits: bool = switch (info.signedness) {
                .unsigned => blk: {
                    const fits = bits_remaining == 0 or byte.bits >> bits_remaining == 0;

                    break :blk .{ 0, fits };
                },
                .signed => blk: {
                    const bits: i7 = @bitCast(byte.bits);

                    // Move the sign bit into the MSB
                    const shifted_bits: i7 = bits << bits_overflowed;

                    const value_sign: i7 = shifted_bits >> 6; // sign extends
                    const bits_sign: i7 = bits >> bits_remaining; // sign extends

                    const fits = bits_remaining == 0 or bits_sign == value_sign;

                    if (uint_bits != info.bits and value_sign != 0) {
                        const sign_extend_mask = @as(UInt, std.math.maxInt(UInt)) << info.bits;
                        val |= sign_extend_mask;
                    }

                    break :blk .{ @bitCast(value_sign), fits };
                },
            };

            switch (info.signedness) {
                .signed => assert(allowed_bits == 0 or allowed_bits == 0x7F),
                .unsigned => comptime assert(allowed_bits == 0),
            }

            while (byte.more) {
                byte = @bitCast(try r.takeByte());
                if (byte.bits != allowed_bits) fits = false;
            }

            return if (fits) blk: {
                @branchHint(.likely);
                break :blk std.math.cast(T, @as(Int, @bitCast(val))) orelse error.Overflow;
            } else error.Overflow;
        }

        comptime assert(bits_written < info.bits);
        if (!byte.more) {
            if (info.signedness == .signed and // can be negative
                byte.bits & 0x40 != 0) // is negative
            {
                const sign_extend_mask = @as(UInt, std.math.maxInt(UInt)) << bits_written;
                val |= sign_extend_mask;
            }
            return std.math.cast(T, @as(Int, @bitCast(val))) orelse error.Overflow;
        }
    }
}

/// Ensures `capacity` data can be buffered without rebasing.
pub fn rebase(r: *Reader, capacity: usize) Error!void {
    if (r.buffer.len - r.seek >= capacity) {
        @branchHint(.likely);
        return;
    }
    return r.vtable.rebase(r, capacity);
}

pub fn defaultRebase(r: *Reader, capacity: usize) Error!void {
    assert(r.buffer.len - r.seek < capacity);
    const data = r.buffer[r.seek..r.end];
    @memmove(r.buffer[0..data.len], data);
    r.seek = 0;
    r.end = data.len;
    assert(r.buffer.len - r.seek >= capacity);
}

test fixed {
    var r: Reader = .fixed("a\x02");
    try testing.expect((try r.takeByte()) == 'a');
    try testing.expect((try r.takeEnum(enum(u8) {
        a = 0,
        b = 99,
        c = 2,
        d = 3,
    }, builtin.cpu.arch.endian())) == .c);
    try testing.expectError(error.EndOfStream, r.takeByte());
}

test peek {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("ab", try r.peek(2));
    try testing.expectEqualStrings("a", try r.peek(1));
}

test peekGreedy {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("abc", try r.peekGreedy(1));
}

test toss {
    var r: Reader = .fixed("abc");
    r.toss(1);
    try testing.expectEqualStrings("bc", r.buffered());
}

test take {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("ab", try r.take(2));
    try testing.expectEqualStrings("c", try r.take(1));
}

test takeArray {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("ab", try r.takeArray(2));
    try testing.expectEqualStrings("c", try r.takeArray(1));
}

test peekArray {
    var r: Reader = .fixed("abc");
    try testing.expectEqualStrings("ab", try r.peekArray(2));
    try testing.expectEqualStrings("a", try r.peekArray(1));
}

test discardAll {
    var r: Reader = .fixed("foobar");
    try r.discardAll(3);
    try testing.expectEqualStrings("bar", try r.take(3));
    try r.discardAll(0);
    try testing.expectError(error.EndOfStream, r.discardAll(1));
}

test discardRemaining {
    var r: Reader = .fixed("foobar");
    r.toss(1);
    try testing.expectEqual(5, try r.discardRemaining());
    try testing.expectEqual(0, try r.discardRemaining());
}

test stream {
    var out_buffer: [10]u8 = undefined;
    var r: Reader = .fixed("foobar");
    var w: Writer = .fixed(&out_buffer);
    // Short streams are possible with this function but not with fixed.
    try testing.expectEqual(2, try r.stream(&w, .limited(2)));
    try testing.expectEqualStrings("fo", w.buffered());
    try testing.expectEqual(4, try r.stream(&w, .unlimited));
    try testing.expectEqualStrings("foobar", w.buffered());
}

test takeSentinel {
    var r: Reader = .fixed("ab\nc");
    try testing.expectEqualStrings("ab", try r.takeSentinel('\n'));
    try testing.expectError(error.EndOfStream, r.takeSentinel('\n'));
    try testing.expectEqualStrings("c", try r.peek(1));
}

test peekSentinel {
    var r: Reader = .fixed("ab\nc");
    try testing.expectEqualStrings("ab", try r.peekSentinel('\n'));
    try testing.expectEqualStrings("ab", try r.peekSentinel('\n'));
    r.toss(3);
    try testing.expectError(error.EndOfStream, r.peekSentinel('\n'));
    try testing.expectEqualStrings("c", try r.peek(1));
}

test takeDelimiterInclusive {
    var r: Reader = .fixed("ab\nc");
    try testing.expectEqualStrings("ab\n", try r.takeDelimiterInclusive('\n'));
    try testing.expectError(error.EndOfStream, r.takeDelimiterInclusive('\n'));
}

test peekDelimiterInclusive {
    var r: Reader = .fixed("ab\nc");
    try testing.expectEqualStrings("ab\n", try r.peekDelimiterInclusive('\n'));
    try testing.expectEqualStrings("ab\n", try r.peekDelimiterInclusive('\n'));
    r.toss(3);
    try testing.expectError(error.EndOfStream, r.peekDelimiterInclusive('\n'));
    try testing.expectEqualStrings("c", try r.peek(1));
}

test takeDelimiterExclusive {
    var r: Reader = .fixed("ab\nc");

    try testing.expectEqualStrings("ab", try r.takeDelimiterExclusive('\n'));
    try testing.expectEqualStrings("", try r.takeDelimiterExclusive('\n'));
    try testing.expectEqualStrings("", try r.takeDelimiterExclusive('\n'));
    try testing.expectEqualStrings("\n", try r.take(1));

    try testing.expectEqualStrings("c", try r.takeDelimiterExclusive('\n'));
    try testing.expectError(error.EndOfStream, r.takeDelimiterExclusive('\n'));
}

test peekDelimiterExclusive {
    var r: Reader = .fixed("ab\nc");

    try testing.expectEqualStrings("ab", try r.peekDelimiterExclusive('\n'));
    try testing.expectEqualStrings("ab", try r.peekDelimiterExclusive('\n'));
    r.toss(2);
    try testing.expectEqualStrings("", try r.peekDelimiterExclusive('\n'));
    try testing.expectEqualStrings("\n", try r.take(1));

    try testing.expectEqualStrings("c", try r.peekDelimiterExclusive('\n'));
    try testing.expectEqualStrings("c", try r.peekDelimiterExclusive('\n'));
    r.toss(1);
    try testing.expectError(error.EndOfStream, r.peekDelimiterExclusive('\n'));
}

test takeDelimiter {
    var r: Reader = .fixed("ab\nc\n\nd");
    try testing.expectEqualStrings("ab", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("c", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("d", (try r.takeDelimiter('\n')).?);
    try testing.expectEqual(null, try r.takeDelimiter('\n'));
    try testing.expectEqual(null, try r.takeDelimiter('\n'));

    r = .fixed("ab\nc\n\nd\n"); // one trailing newline does not affect behavior
    try testing.expectEqualStrings("ab", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("c", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("", (try r.takeDelimiter('\n')).?);
    try testing.expectEqualStrings("d", (try r.takeDelimiter('\n')).?);
    try testing.expectEqual(null, try r.takeDelimiter('\n'));
    try testing.expectEqual(null, try r.takeDelimiter('\n'));
}

test streamDelimiter {
    var out_buffer: [10]u8 = undefined;
    var r: Reader = .fixed("foo\nbars");
    var w: Writer = .fixed(&out_buffer);
    try testing.expectEqual(3, try r.streamDelimiter(&w, '\n'));
    try testing.expectEqualStrings("foo", w.buffered());
    try testing.expectEqual(0, try r.streamDelimiter(&w, '\n'));
    r.toss(1);
    try testing.expectError(error.EndOfStream, r.streamDelimiter(&w, '\n'));
}

test streamDelimiterEnding {
    var out_buffer: [10]u8 = undefined;
    var r: Reader = .fixed("foo\nbars");
    var w: Writer = .fixed(&out_buffer);
    try testing.expectEqual(3, try r.streamDelimiterEnding(&w, '\n'));
    try testing.expectEqualStrings("foo", w.buffered());
    r.toss(1);
    try testing.expectEqual(4, try r.streamDelimiterEnding(&w, '\n'));
    try testing.expectEqualStrings("foobars", w.buffered());
    try testing.expectEqual(0, try r.streamDelimiterEnding(&w, '\n'));
    try testing.expectEqual(0, try r.streamDelimiterEnding(&w, '\n'));
}

test streamDelimiterLimit {
    var out_buffer: [10]u8 = undefined;
    var r: Reader = .fixed("foo\nbars");
    var w: Writer = .fixed(&out_buffer);
    try testing.expectError(error.StreamTooLong, r.streamDelimiterLimit(&w, '\n', .limited(2)));
    try testing.expectEqual(1, try r.streamDelimiterLimit(&w, '\n', .limited(3)));
    try testing.expectEqualStrings("\n", try r.take(1));
    try testing.expectEqual(4, try r.streamDelimiterLimit(&w, '\n', .unlimited));
    try testing.expectEqualStrings("foobars", w.buffered());
}

test discardDelimiterExclusive {
    var r: Reader = .fixed("foob\nar");
    try testing.expectEqual(4, try r.discardDelimiterExclusive('\n'));
    try testing.expectEqualStrings("\n", try r.take(1));
    try testing.expectEqual(2, try r.discardDelimiterExclusive('\n'));
    try testing.expectEqual(0, try r.discardDelimiterExclusive('\n'));
}

test discardDelimiterInclusive {
    var r: Reader = .fixed("foob\nar");
    try testing.expectEqual(5, try r.discardDelimiterInclusive('\n'));
    try testing.expectError(error.EndOfStream, r.discardDelimiterInclusive('\n'));
}

test discardDelimiterLimit {
    var r: Reader = .fixed("foob\nar");
    try testing.expectError(error.StreamTooLong, r.discardDelimiterLimit('\n', .limited(4)));
    try testing.expectEqual(0, try r.discardDelimiterLimit('\n', .limited(2)));
    try testing.expectEqualStrings("\n", try r.take(1));
    try testing.expectEqual(2, try r.discardDelimiterLimit('\n', .unlimited));
    try testing.expectEqual(0, try r.discardDelimiterLimit('\n', .unlimited));
}

test fill {
    var r: Reader = .fixed("abc");
    try r.fill(1);
    try r.fill(3);
}

test takeByte {
    var r: Reader = .fixed("ab");
    try testing.expectEqual('a', try r.takeByte());
    try testing.expectEqual('b', try r.takeByte());
    try testing.expectError(error.EndOfStream, r.takeByte());
}

test takeByteSigned {
    var r: Reader = .fixed(&.{ 255, 5 });
    try testing.expectEqual(-1, try r.takeByteSigned());
    try testing.expectEqual(5, try r.takeByteSigned());
    try testing.expectError(error.EndOfStream, r.takeByteSigned());
}

test takeInt {
    var r: Reader = .fixed(&.{ 0x12, 0x34, 0x56 });
    try testing.expectEqual(0x1234, try r.takeInt(u16, .big));
    try testing.expectError(error.EndOfStream, r.takeInt(u16, .little));
}

test takeVarInt {
    var r: Reader = .fixed(&.{ 0x12, 0x34, 0x56 });
    try testing.expectEqual(0x123456, try r.takeVarInt(u64, .big, 3));
    try testing.expectError(error.EndOfStream, r.takeVarInt(u16, .little, 1));
}

test takeStructPointer {
    var r: Reader = .fixed(&.{ 0x12, 0x00, 0x34, 0x56 });
    const S = extern struct { a: u8, b: u16 };
    switch (native_endian) {
        .little => try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x5634 }), (try r.takeStructPointer(S)).*),
        .big => try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), (try r.takeStructPointer(S)).*),
    }
    try testing.expectError(error.EndOfStream, r.takeStructPointer(S));
}

test peekStructPointer {
    var r: Reader = .fixed(&.{ 0x12, 0x00, 0x34, 0x56 });
    const S = extern struct { a: u8, b: u16 };
    switch (native_endian) {
        .little => {
            try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x5634 }), (try r.peekStructPointer(S)).*);
            try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x5634 }), (try r.peekStructPointer(S)).*);
        },
        .big => {
            try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), (try r.peekStructPointer(S)).*);
            try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), (try r.peekStructPointer(S)).*);
        },
    }
}

test takeStruct {
    var r: Reader = .fixed(&.{ 0x12, 0x00, 0x34, 0x56 });
    const S = extern struct { a: u8, b: u16 };
    try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), try r.takeStruct(S, .big));
    try testing.expectError(error.EndOfStream, r.takeStruct(S, .little));
}

test peekStruct {
    var r: Reader = .fixed(&.{ 0x12, 0x00, 0x34, 0x56 });
    const S = extern struct { a: u8, b: u16 };
    try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x3456 }), try r.peekStruct(S, .big));
    try testing.expectEqual(@as(S, .{ .a = 0x12, .b = 0x5634 }), try r.peekStruct(S, .little));
}

test takeEnum {
    var r: Reader = .fixed(&.{ 2, 0, 1 });
    const E1 = enum(u8) { a, b, c };
    const E2 = enum(u16) { _ };
    try testing.expectEqual(E1.c, try r.takeEnum(E1, .little));
    try testing.expectEqual(@as(E2, @fromBackingInt(@intCast(0x0001))), try r.takeEnum(E2, .big));
}

test readSliceShort {
    var r: Reader = .fixed("HelloFren");
    var buf: [5]u8 = undefined;
    try testing.expectEqual(5, try r.readSliceShort(&buf));
    try testing.expectEqualStrings("Hello", buf[0..5]);
    try testing.expectEqual(4, try r.readSliceShort(&buf));
    try testing.expectEqualStrings("Fren", buf[0..4]);
    try testing.expectEqual(0, try r.readSliceShort(&buf));
}

test "readSliceShort with smaller buffer than Reader" {
    var reader_buf: [15]u8 = undefined;
    const str = "This is a test";
    var one_byte_stream: testing.Reader = .init(&reader_buf, &.{
        .{ .buffer = str },
    });
    one_byte_stream.artificial_limit = .limited(1);

    var buf: [14]u8 = undefined;
    try testing.expectEqual(14, try one_byte_stream.interface.readSliceShort(&buf));
    try testing.expectEqualStrings(str, &buf);
}

test "readSliceShort with indirect reader" {
    var r: Reader = .fixed("HelloFren");
    var ri_buf: [3]u8 = undefined;
    var ri: std.testing.ReaderIndirect = .init(&r, &ri_buf);
    var buf: [5]u8 = undefined;
    try testing.expectEqual(5, try ri.interface.readSliceShort(&buf));
    try testing.expectEqualStrings("Hello", buf[0..5]);
    try testing.expectEqual(4, try ri.interface.readSliceShort(&buf));
    try testing.expectEqualStrings("Fren", buf[0..4]);
    try testing.expectEqual(0, try ri.interface.readSliceShort(&buf));
}

test readAllocAll {
    const allocator = testing.allocator;
    var r: Reader = .fixed("HelloFren");

    const s1 = try r.readAllocAll(allocator, 5);
    defer allocator.free(s1);
    try testing.expectEqualStrings("Hello", s1);

    const s2 = try r.readAllocAll(allocator, 4);
    defer allocator.free(s2);
    try testing.expectEqualStrings("Fren", s2);
}

test "readAllocAll with buffer bigger than content" {
    const allocator = testing.allocator;
    var r: Reader = .fixed("HelloFren");

    const s1 = try r.readAllocAll(allocator, 5);
    defer allocator.free(s1);
    try testing.expectEqualStrings("Hello", s1);

    const res = r.readAllocAll(allocator, 10);
    try testing.expectError(Error.EndOfStream, res);
}

test readAllocShort {
    var r: Reader = .fixed("HelloFren");

    const s1 = try r.readAllocShort(testing.allocator, 5);
    defer testing.allocator.free(s1);
    try testing.expectEqualStrings("Hello", s1);

    const s2 = try r.readAllocShort(testing.allocator, 10);
    defer testing.allocator.free(s2);
    try testing.expectEqualStrings("Fren", s2);

    const s3 = try r.readAllocShort(testing.allocator, 10);
    defer testing.allocator.free(s3);
    try testing.expectEqual(0, s3.len);
}

test readVec {
    var r: Reader = .fixed(std.ascii.letters);
    var flat_buffer: [52]u8 = undefined;
    var bufs: [2][]u8 = .{
        flat_buffer[0..26],
        flat_buffer[26..],
    };
    // Short reads are possible with this function but not with fixed.
    try testing.expectEqual(26 * 2, try r.readVec(&bufs));
    try testing.expectEqualStrings(std.ascii.letters[0..26], bufs[0]);
    try testing.expectEqualStrings(std.ascii.letters[26..], bufs[1]);
}

test "expected error.EndOfStream" {
    // Unit test inspired by https://github.com/ziglang/zig/issues/17733
    var buffer: [3]u8 = undefined;
    var r: std.Io.Reader = .fixed(&buffer);
    r.end = 0; // capacity 3, but empty
    try std.testing.expectError(error.EndOfStream, r.takeEnum(enum(u8) { a, b }, .little));
    try std.testing.expectError(error.EndOfStream, r.take(3));
}

test "readVec at end" {
    var reader_buffer: [8]u8 = "abcd1234".*;
    var reader: testing.Reader = .init(&reader_buffer, &.{});
    reader.interface.end = reader_buffer.len;

    var out: [16]u8 = undefined;
    var vecs: [1][]u8 = .{&out};
    try testing.expectEqual(8, try reader.interface.readVec(&vecs));
    try testing.expectEqualStrings("abcd1234", vecs[0][0..8]);
}

fn endingStream(r: *Reader, w: *Writer, limit: Limit) StreamError!usize {
    _ = r;
    _ = w;
    _ = limit;
    return error.EndOfStream;
}

fn endingReadVec(r: *Reader, data: [][]u8) Error!usize {
    _ = r;
    _ = data;
    return error.EndOfStream;
}

fn endingDiscard(r: *Reader, limit: Limit) Error!usize {
    _ = r;
    _ = limit;
    return error.EndOfStream;
}

fn endingRebase(r: *Reader, capacity: usize) RebaseError!void {
    _ = r;
    _ = capacity;
    return error.EndOfStream;
}

fn failingStream(r: *Reader, w: *Writer, limit: Limit) StreamError!usize {
    _ = r;
    _ = w;
    _ = limit;
    return error.ReadFailed;
}

fn failingDiscard(r: *Reader, limit: Limit) Error!usize {
    _ = r;
    _ = limit;
    return error.ReadFailed;
}

test "discardAll that has to call discard multiple times on an indirect reader" {
    var fr: Reader = .fixed("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
    var indirect_buffer: [3]u8 = undefined;
    var tri: std.testing.ReaderIndirect = .init(&fr, &indirect_buffer);
    const r = &tri.interface;

    try r.discardAll(10);
    var remaining_buf: [16]u8 = undefined;
    try r.readSliceAll(&remaining_buf);
    try std.testing.expectEqualStrings(fr.buffer[10..], remaining_buf[0..]);
}

test "readAlloc when the backing reader provides one byte at a time" {
    const str = "This is a test";
    var tiny_buffer: [1]u8 = undefined;
    var one_byte_stream: testing.Reader = .init(&tiny_buffer, &.{
        .{ .buffer = str },
    });
    one_byte_stream.artificial_limit = .limited(1);
    const res = try one_byte_stream.interface.allocRemaining(std.testing.allocator, .unlimited);
    defer std.testing.allocator.free(res);
    try std.testing.expectEqualStrings(str, res);
}

test "takeDelimiterInclusive when it rebases" {
    const written_line = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n";
    var buffer: [128]u8 = undefined;
    var tr: std.testing.Reader = .init(&buffer, &.{
        .{ .buffer = written_line },
        .{ .buffer = written_line },
        .{ .buffer = written_line },
        .{ .buffer = written_line },
        .{ .buffer = written_line },
        .{ .buffer = written_line },
    });
    const r = &tr.interface;
    for (0..6) |_| {
        try std.testing.expectEqualStrings(written_line, try r.takeDelimiterInclusive('\n'));
    }
}

test "takeDelimiterInclusive on an indirect reader when it rebases" {
    const written_line = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n";
    var buffer: [128]u8 = undefined;
    var tr: std.testing.Reader = .init(&buffer, &.{
        .{ .buffer = written_line[0..4] },
        .{ .buffer = written_line[4..] },
        .{ .buffer = written_line },
        .{ .buffer = written_line },
        .{ .buffer = written_line },
        .{ .buffer = written_line },
        .{ .buffer = written_line },
    });
    var indirect_buffer: [128]u8 = undefined;
    var tri: std.testing.ReaderIndirect = .init(&tr.interface, &indirect_buffer);
    const r = &tri.interface;
    for (0..6) |_| {
        try std.testing.expectEqualStrings(written_line, try r.takeDelimiterInclusive('\n'));
    }
}

test "takeStruct and peekStruct packed" {
    var r: Reader = .fixed(&.{ 0b11110000, 0b00110011 });
    const S = packed struct(u16) { a: u2, b: u6, c: u7, d: u1 };

    try testing.expectEqual(@as(S, .{
        .a = 0b11,
        .b = 0b001100,
        .c = 0b1110000,
        .d = 0b1,
    }), try r.peekStruct(S, .big));

    try testing.expectEqual(@as(S, .{
        .a = 0b11,
        .b = 0b001100,
        .c = 0b1110000,
        .d = 0b1,
    }), try r.takeStruct(S, .big));

    try testing.expectError(error.EndOfStream, r.takeStruct(S, .little));
}

test allocRemaining {
    {
        var r: Reader = .fixed("abc");
        const str = try r.allocRemaining(testing.allocator, .unlimited);
        defer testing.allocator.free(str);
        try testing.expectEqualStrings("abc", str);
    }
    {
        var r: Reader = .fixed("abc");
        const str = try r.allocRemaining(testing.allocator, .limited(5));
        defer testing.allocator.free(str);
        try testing.expectEqualStrings("abc", str);
    }
    {
        var r: Reader = .fixed("abc");
        const str = try r.allocRemaining(testing.allocator, .limited(3));
        defer testing.allocator.free(str);
        try testing.expectEqualStrings("abc", str);
    }
    {
        var r: Reader = .fixed("abcd");
        try testing.expectError(error.StreamTooLong, r.allocRemaining(testing.allocator, .limited(3)));
    }
}

/// Provides a `Reader` implementation by passing data from an underlying
/// reader through `Hasher.update`.
///
/// The underlying reader is best unbuffered.
///
/// This implementation makes suboptimal buffering decisions due to being
/// generic. A better solution will involve creating a reader for each hash
/// function, where the discard buffer can be tailored to the hash
/// implementation details.
pub fn Hashed(comptime Hasher: type) type {
    return struct {
        in: *Reader,
        hasher: Hasher,
        reader: Reader,

        pub fn init(in: *Reader, hasher: Hasher, buffer: []u8) @This() {
            return .{
                .in = in,
                .hasher = hasher,
                .reader = .{
                    .vtable = &.{
                        .stream = @This().stream,
                        .readVec = @This().readVec,
                        .discard = @This().discard,
                    },
                    .buffer = buffer,
                    .end = 0,
                    .seek = 0,
                },
            };
        }

        fn stream(r: *Reader, w: *Writer, limit: Limit) StreamError!usize {
            const this: *@This() = @alignCast(@fieldParentPtr("reader", r));
            const data = limit.slice(try w.writableSliceGreedy(1));
            var vec: [1][]u8 = .{data};
            const n = try this.in.readVec(&vec);
            this.hasher.update(data[0..n]);
            w.advance(n);
            return n;
        }

        fn readVec(r: *Reader, data: [][]u8) Error!usize {
            const this: *@This() = @alignCast(@fieldParentPtr("reader", r));
            var vecs: [8][]u8 = undefined; // Arbitrarily chosen amount.
            const dest_n, const data_size = try r.writableVector(&vecs, data);
            const dest = vecs[0..dest_n];
            const n = try this.in.readVec(dest);
            var remaining: usize = n;
            for (dest) |slice| {
                if (remaining < slice.len) {
                    this.hasher.update(slice[0..remaining]);
                    remaining = 0;
                    break;
                } else {
                    remaining -= slice.len;
                    this.hasher.update(slice);
                }
            }
            assert(remaining == 0);
            if (n > data_size) {
                r.end += n - data_size;
                return data_size;
            }
            return n;
        }

        fn discard(r: *Reader, limit: Limit) Error!usize {
            const this: *@This() = @alignCast(@fieldParentPtr("reader", r));
            const peeked = limit.slice(try this.in.peekGreedy(1));
            this.hasher.update(peeked);
            this.in.toss(peeked.len);
            return peeked.len;
        }
    };
}

pub fn writableVectorPosix(r: *Reader, buffer: []std.posix.iovec, data: []const []u8) Error!struct { usize, usize } {
    var i: usize = 0;
    var n: usize = 0;
    if (r.seek == r.end) {
        for (data) |buf| {
            if (buffer.len - i == 0) return .{ i, n };
            if (buf.len != 0) {
                buffer[i] = .{ .base = buf.ptr, .len = buf.len };
                i += 1;
                n += buf.len;
            }
        }
        const buf = r.buffer;
        if (buf.len != 0) {
            r.seek = 0;
            r.end = 0;
            buffer[i] = .{ .base = buf.ptr, .len = buf.len };
            i += 1;
        }
    } else {
        const buf = r.buffer[r.end..];
        buffer[i] = .{ .base = buf.ptr, .len = buf.len };
        i += 1;
    }
    return .{ i, n };
}

pub fn writableVectorWsa(
    r: *Reader,
    buffer: []std.os.windows.AFD.WSABUF(.@"var"),
    data: []const []u8,
) Error!struct { usize, usize } {
    var i: usize = 0;
    var n: usize = 0;
    if (r.seek == r.end) {
        for (data) |buf| {
            if (buffer.len - i == 0) return .{ i, n };
            if (buf.len == 0) continue;
            if (std.math.cast(u32, buf.len)) |len| {
                buffer[i] = .{ .buf = buf.ptr, .len = len };
                i += 1;
                n += len;
                continue;
            }
            buffer[i] = .{ .buf = buf.ptr, .len = std.math.maxInt(u32) };
            i += 1;
            n += std.math.maxInt(u32);
            return .{ i, n };
        }
        const buf = r.buffer;
        if (buf.len != 0) {
            r.seek = 0;
            r.end = 0;
            if (std.math.cast(u32, buf.len)) |len| {
                buffer[i] = .{ .buf = buf.ptr, .len = len };
            } else {
                buffer[i] = .{ .buf = buf.ptr, .len = std.math.maxInt(u32) };
            }
            i += 1;
        }
    } else {
        buffer[i] = .{
            .buf = r.buffer.ptr + r.end,
            .len = @min(std.math.maxInt(u32), r.buffer.len - r.end),
        };
        i += 1;
    }
    return .{ i, n };
}

pub fn writableVector(r: *Reader, buffer: [][]u8, data: []const []u8) Error!struct { usize, usize } {
    var i: usize = 0;
    var n: usize = 0;
    if (r.seek == r.end) {
        for (data) |buf| {
            if (buffer.len - i == 0) return .{ i, n };
            if (buf.len != 0) {
                buffer[i] = buf;
                i += 1;
                n += buf.len;
            }
        }
        if (r.buffer.len != 0) {
            r.seek = 0;
            r.end = 0;
            buffer[i] = r.buffer;
            i += 1;
        }
    } else {
        buffer[i] = r.buffer[r.end..];
        i += 1;
    }
    return .{ i, n };
}

test "deserialize signed LEB128" {
    // Small values
    try testing.expectEqual(5, testLeb128(i7, "\x05"));
    try testing.expectEqual(53, testLeb128(i64, "\x35"));

    try testing.expectEqual(-6, testLeb128(i7, "\x7A"));
    try testing.expectEqual(-23, testLeb128(i64, "\x69"));

    // Random values
    try testing.expectEqual(90, testLeb128(i8, "\xDA\x00"));
    try testing.expectEqual(3434, testLeb128(i16, "\xEA\x1A"));
    try testing.expectEqual(1505683543, testLeb128(i32, "\xD7\xD0\xFB\xCD\x05"));
    try testing.expectEqual(105721575804011595, testLeb128(i64, "\xCB\x88\x92\xD7\xE8\xA6\xE6\xBB\x01"));
    try testing.expectEqual(51316697993548595875823294343650416388, testLeb128(i128, "\x84\xAE\xAC\xFC\xE4\xA0\xCD\xE2\x87\xED\x83\xB2\x87\xAA\xA3\x9E\x9B\xCD\x00"));

    try testing.expectEqual(-68, testLeb128(i8, "\xBC\x7F"));
    try testing.expectEqual(-20174, testLeb128(i16, "\xB2\xE2\x7E"));
    try testing.expectEqual(-166511141, testLeb128(i32, "\xDB\xFB\xCC\xB0\x7F"));
    try testing.expectEqual(-4368809844285451825, testLeb128(i64, "\xCF\xA3\x8B\xA1\xFF\xD2\xB7\xAF\x43"));
    try testing.expectEqual(-43250117698642799010758201165100952046, testLeb128(i128, "\x92\xAC\xDB\xA4\xEC\xDE\xB9\x95\xD1\xBA\xEC\xB0\xD7\x80\xA4\xAA\xF6\xBE\x7F"));

    // {min,max} values
    try testing.expectEqual(std.math.maxInt(i8), testLeb128(i8, "\xFF\x00"));
    try testing.expectEqual(std.math.maxInt(i16), testLeb128(i16, "\xFF\xFF\x01"));
    try testing.expectEqual(std.math.maxInt(i32), testLeb128(i32, "\xFF\xFF\xFF\xFF\x07"));
    try testing.expectEqual(std.math.maxInt(i64), testLeb128(i64, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00"));
    try testing.expectEqual(std.math.maxInt(i128), testLeb128(i128, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));

    try testing.expectEqual(std.math.minInt(i8), testLeb128(i8, "\x80\x7F"));
    try testing.expectEqual(std.math.minInt(i16), testLeb128(i16, "\x80\x80\x7E"));
    try testing.expectEqual(std.math.minInt(i32), testLeb128(i32, "\x80\x80\x80\x80\x78"));
    try testing.expectEqual(std.math.minInt(i64), testLeb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7F"));
    try testing.expectEqual(std.math.minInt(i128), testLeb128(i128, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7E"));

    // Specific cases
    try testing.expectEqual(0, testLeb128(i2, "\x00"));
    try testing.expectEqual(0, testLeb128(i8, "\x00"));

    try testing.expectEqual(1, testLeb128(i2, "\x01"));
    try testing.expectEqual(1, testLeb128(i8, "\x01"));

    try testing.expectEqual(-1, testLeb128(i2, "\x7F"));
    try testing.expectEqual(-1, testLeb128(i8, "\x7F"));

    const end_of_stream: [20]u8 = @splat(0x80);
    const overflow: [21]u8 = end_of_stream ++ .{0x01};
    const long_zero: [21]u8 = end_of_stream ++ .{0x00};
    const long_one: [22]u8 = .{0x81} ++ end_of_stream ++ .{0x00};
    const long_minus_one: [20]u8 = @as([19]u8, @splat(0xFF)) ++ .{0x7F};

    // Truncated
    try testing.expectError(error.EndOfStream, testLeb128(i16, "\x80\x80\x84\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(i16, "\x80\x80\x80\x84\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(i32, "\x80\x80\x80\x80\x90"));

    try testing.expectError(error.EndOfStream, testLeb128(i7, ""));
    try testing.expectError(error.EndOfStream, testLeb128(i8, ""));
    try testing.expectError(error.EndOfStream, testLeb128(i14, ""));
    try testing.expectError(error.EndOfStream, testLeb128(i128, ""));

    try testing.expectError(error.EndOfStream, testLeb128(i7, "\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(i8, "\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(i14, "\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(i128, "\x80"));

    try testing.expectError(error.EndOfStream, testLeb128(i7, &end_of_stream));
    try testing.expectError(error.EndOfStream, testLeb128(i8, &end_of_stream));
    try testing.expectError(error.EndOfStream, testLeb128(i14, &end_of_stream));
    try testing.expectError(error.EndOfStream, testLeb128(i128, &end_of_stream));

    // Overflow
    try testing.expectError(error.Overflow, testLeb128(i8, "\x80\x01"));
    try testing.expectError(error.Overflow, testLeb128(i8, "\xFF\x7E"));
    try testing.expectError(error.Overflow, testLeb128(i8, "\x80\x80\x40"));
    try testing.expectError(error.Overflow, testLeb128(i16, "\x80\x80\x80\x40"));
    try testing.expectError(error.Overflow, testLeb128(i32, "\x80\x80\x80\x80\x08"));
    try testing.expectError(error.Overflow, testLeb128(i32, "\x80\x80\x80\x80\x40"));
    try testing.expectError(error.Overflow, testLeb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01"));
    try testing.expectError(error.Overflow, testLeb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x40"));

    try testing.expectError(error.Overflow, testLeb128(i7, &overflow));
    try testing.expectError(error.Overflow, testLeb128(i8, &overflow));
    try testing.expectError(error.Overflow, testLeb128(i14, &overflow));
    try testing.expectError(error.Overflow, testLeb128(i128, &overflow));

    // Extra padding
    try testing.expectEqual(-1, testLeb128(i32, "\xFF\xFF\xFF\xFF\x7F"));
    try testing.expectEqual(-1, testLeb128(i64, "\xFF\x7F"));
    try testing.expectEqual(0x7F, testLeb128(i64, "\xFF\x00"));
    try testing.expectEqual(0x7F, testLeb128(i64, "\xFF\x80\x00"));
    try testing.expectEqual(0x80, testLeb128(i64, "\x80\x81\x00"));
    try testing.expectEqual(0x80, testLeb128(i64, "\x80\x81\x80\x00"));

    try testing.expectEqual(0, testLeb128(i7, &long_zero));
    try testing.expectEqual(0, testLeb128(i8, &long_zero));
    try testing.expectEqual(0, testLeb128(i14, &long_zero));
    try testing.expectEqual(0, testLeb128(i128, &long_zero));

    try testing.expectEqual(1, testLeb128(i2, &long_one));
    try testing.expectEqual(1, testLeb128(i7, &long_one));
    try testing.expectEqual(1, testLeb128(i8, &long_one));
    try testing.expectEqual(1, testLeb128(i14, &long_one));
    try testing.expectEqual(1, testLeb128(i128, &long_one));

    try testing.expectEqual(-1, testLeb128(i2, &long_minus_one));
    try testing.expectEqual(-1, testLeb128(i7, &long_minus_one));
    try testing.expectEqual(-1, testLeb128(i8, &long_minus_one));
    try testing.expectEqual(-1, testLeb128(i14, &long_minus_one));
    try testing.expectEqual(-1, testLeb128(i128, &long_minus_one));

    // Decode byte boundaries
    try testing.expectEqual(std.math.maxInt(i7), testLeb128(i7, "\x3F"));
    try testing.expectEqual(std.math.maxInt(i7) + 1, testLeb128(i8, "\xC0\x00"));
    try testing.expectEqual(std.math.maxInt(i14), testLeb128(i14, "\xFF\x3F"));
    try testing.expectEqual(std.math.maxInt(i14) + 1, testLeb128(i15, "\x80\xC0\x00"));
    try testing.expectEqual(std.math.maxInt(i49), testLeb128(i49, "\xFF\xFF\xFF\xFF\xFF\xFF\x3F"));
    try testing.expectEqual(std.math.maxInt(i49) + 1, testLeb128(i50, "\x80\x80\x80\x80\x80\x80\xC0\x00"));
    try testing.expectEqual(std.math.maxInt(i56), testLeb128(i56, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x3F"));
    try testing.expectEqual(std.math.maxInt(i56) + 1, testLeb128(i57, "\x80\x80\x80\x80\x80\x80\x80\xC0\x00"));
    try testing.expectEqual(std.math.maxInt(i63), testLeb128(i63, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x3F"));
    try testing.expectEqual(std.math.maxInt(i63) + 1, testLeb128(i64, "\x80\x80\x80\x80\x80\x80\x80\x80\xC0\x00"));

    try testing.expectEqual(std.math.minInt(i7), testLeb128(i7, "\x40"));
    try testing.expectEqual(std.math.minInt(i7) - 1, testLeb128(i8, "\xBF\x7F"));
    try testing.expectEqual(std.math.minInt(i14), testLeb128(i14, "\x80\x40"));
    try testing.expectEqual(std.math.minInt(i14) - 1, testLeb128(i15, "\xFF\xBF\x7F"));
    try testing.expectEqual(std.math.minInt(i49), testLeb128(i49, "\x80\x80\x80\x80\x80\x80\x40"));
    try testing.expectEqual(std.math.minInt(i49) - 1, testLeb128(i50, "\xFF\xFF\xFF\xFF\xFF\xFF\xBF\x7F"));
    try testing.expectEqual(std.math.minInt(i56), testLeb128(i56, "\x80\x80\x80\x80\x80\x80\x80\x40"));
    try testing.expectEqual(std.math.minInt(i56) - 1, testLeb128(i57, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xBF\x7F"));
    try testing.expectEqual(std.math.minInt(i63), testLeb128(i63, "\x80\x80\x80\x80\x80\x80\x80\x80\x40"));
    try testing.expectEqual(std.math.minInt(i63) - 1, testLeb128(i64, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xBF\x7F"));
}

test "deserialize unsigned LEB128" {
    // Small values
    try testing.expectEqual(46, testLeb128(u7, "\x2E"));
    try testing.expectEqual(117, testLeb128(u64, "\x75"));

    // Random values
    try testing.expectEqual(224, testLeb128(u8, "\xE0\x01"));
    try testing.expectEqual(53023, testLeb128(u16, "\x9F\x9E\x03"));
    try testing.expectEqual(2609971022, testLeb128(u32, "\xCE\xFE\xC3\xDC\x09"));
    try testing.expectEqual(10223253173206528843, testLeb128(u64, "\xCB\xE6\xF0\xEE\x88\xD3\x92\xF0\x8D\x01"));
    try testing.expectEqual(67831258924174241363439488509570048548, testLeb128(u128, "\xA4\xC4\xD7\xE9\x8C\xD2\x86\x80\xBC\xAC\xE5\xAB\xB4\xA2\xD1\xE9\x87\x66"));

    // max values
    try testing.expectEqual(std.math.maxInt(u8), testLeb128(u8, "\xFF\x01"));
    try testing.expectEqual(std.math.maxInt(u16), testLeb128(u16, "\xFF\xFF\x03"));
    try testing.expectEqual(std.math.maxInt(u32), testLeb128(u32, "\xFF\xFF\xFF\xFF\x0F"));
    try testing.expectEqual(std.math.maxInt(u64), testLeb128(u64, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
    try testing.expectEqual(std.math.maxInt(u128), testLeb128(u128, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x03"));

    // Specific cases
    try testing.expectEqual(0, testLeb128(u0, "\x00"));
    try testing.expectEqual(0, testLeb128(u1, "\x00"));
    try testing.expectEqual(0, testLeb128(u8, "\x00"));

    try testing.expectEqual(1, testLeb128(u1, "\x01"));
    try testing.expectEqual(1, testLeb128(u8, "\x01"));

    const end_of_stream: [20]u8 = @splat(0x80);
    const overflow: [21]u8 = end_of_stream ++ .{0x01};
    const long_zero: [21]u8 = end_of_stream ++ .{0x00};
    const long_one: [22]u8 = .{0x81} ++ end_of_stream ++ .{0x00};

    // Truncated
    try testing.expectError(error.EndOfStream, testLeb128(u16, "\x80\x80\x84\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(u16, "\x80\x80\x80\x84\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(u32, "\x80\x80\x80\x80\x90"));

    try testing.expectError(error.EndOfStream, testLeb128(u7, ""));
    try testing.expectError(error.EndOfStream, testLeb128(u8, ""));
    try testing.expectError(error.EndOfStream, testLeb128(u14, ""));
    try testing.expectError(error.EndOfStream, testLeb128(u128, ""));

    try testing.expectError(error.EndOfStream, testLeb128(u7, "\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(u8, "\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(u14, "\x80"));
    try testing.expectError(error.EndOfStream, testLeb128(u128, "\x80"));

    try testing.expectError(error.EndOfStream, testLeb128(u7, &end_of_stream));
    try testing.expectError(error.EndOfStream, testLeb128(u8, &end_of_stream));
    try testing.expectError(error.EndOfStream, testLeb128(u14, &end_of_stream));
    try testing.expectError(error.EndOfStream, testLeb128(u128, &end_of_stream));

    // Overflow
    try testing.expectError(error.Overflow, testLeb128(u0, "\x01"));
    try testing.expectError(error.Overflow, testLeb128(u1, "\x02"));
    try testing.expectError(error.Overflow, testLeb128(u8, "\x80\x02"));
    try testing.expectError(error.Overflow, testLeb128(u8, "\x80\x80\x40"));
    try testing.expectError(error.Overflow, testLeb128(u16, "\x80\x80\x80\x40"));
    try testing.expectError(error.Overflow, testLeb128(u32, "\x80\x80\x80\x80\x40"));
    try testing.expectError(error.Overflow, testLeb128(u64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x40"));

    try testing.expectError(error.Overflow, testLeb128(u7, &overflow));
    try testing.expectError(error.Overflow, testLeb128(u8, &overflow));
    try testing.expectError(error.Overflow, testLeb128(u14, &overflow));
    try testing.expectError(error.Overflow, testLeb128(u128, &overflow));

    // Extra padding
    try testing.expectEqual(0x7F, testLeb128(u64, "\xFF\x00"));
    try testing.expectEqual(0x7F, testLeb128(u64, "\xFF\x80\x00"));
    try testing.expectEqual(0x80, testLeb128(u64, "\x80\x81\x00"));
    try testing.expectEqual(0x80, testLeb128(u64, "\x80\x81\x80\x80\x00"));

    try testing.expectEqual(0, testLeb128(u0, &long_zero));
    try testing.expectEqual(0, testLeb128(u7, &long_zero));
    try testing.expectEqual(0, testLeb128(u8, &long_zero));
    try testing.expectEqual(0, testLeb128(u14, &long_zero));
    try testing.expectEqual(0, testLeb128(u128, &long_zero));

    try testing.expectEqual(1, testLeb128(u1, &long_one));
    try testing.expectEqual(1, testLeb128(u7, &long_one));
    try testing.expectEqual(1, testLeb128(u8, &long_one));
    try testing.expectEqual(1, testLeb128(u14, &long_one));
    try testing.expectEqual(1, testLeb128(u128, &long_one));

    // Decode byte boundaries
    try testing.expectEqual(std.math.maxInt(u7), testLeb128(u7, "\x7F"));
    try testing.expectEqual(std.math.maxInt(u7) + 1, testLeb128(u8, "\x80\x01"));
    try testing.expectEqual(std.math.maxInt(u14), testLeb128(u14, "\xFF\x7F"));
    try testing.expectEqual(std.math.maxInt(u14) + 1, testLeb128(u15, "\x80\x80\x01"));
    try testing.expectEqual(std.math.maxInt(u49), testLeb128(u49, "\xFF\xFF\xFF\xFF\xFF\xFF\x7F"));
    try testing.expectEqual(std.math.maxInt(u49) + 1, testLeb128(u50, "\x80\x80\x80\x80\x80\x80\x80\x01"));
    try testing.expectEqual(std.math.maxInt(u56), testLeb128(u56, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F"));
    try testing.expectEqual(std.math.maxInt(u56) + 1, testLeb128(u57, "\x80\x80\x80\x80\x80\x80\x80\x80\x01"));
    try testing.expectEqual(std.math.maxInt(u63), testLeb128(u63, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F"));
    try testing.expectEqual(std.math.maxInt(u63) + 1, testLeb128(u64, "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01"));
}

fn testLeb128(comptime T: type, encoded: []const u8) !T {
    var reader: std.Io.Reader = .fixed(encoded);
    const result = reader.takeLeb128(T);
    try testing.expectEqual(reader.seek, reader.end);
    return result;
}

test streamExactPreserve {
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .stream_len = 5 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 9, .preserve = 5, .stream_len = 2 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .stream_len = 6 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 6 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .stream_len = 10 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 10 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 11 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 80 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 85 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 6 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 11 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 80 });
    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 85 });
}

fn testStreamExactPreserve(options: struct { buf_len: u4, fill_len: u4, preserve: u4, stream_len: u8 }) !void {
    assert(options.fill_len <= options.buf_len);
    assert(options.preserve <= options.buf_len);

    var input: [256]u8 = undefined;
    for (&input, 0..) |*val, i| {
        val.* = @as(u8, @intCast(i % 26)) + 'a';
    }
    const expected_out = input[0 .. options.fill_len + options.stream_len];
    const expected_preserved = expected_out[expected_out.len -| options.preserve..];

    var r: Reader = .fixed(&input);
    var out_buf: [256]u8 = undefined;
    var fw: Writer = .fixed(&out_buf);
    var indirect_buffer: [16]u8 = undefined;
    var twi: std.testing.WriterIndirect = .init(&fw, indirect_buffer[0..options.buf_len]);
    const w = &twi.interface;

    try r.streamExact(w, options.fill_len);
    try r.streamExactPreserve(w, options.preserve, options.stream_len);

    try std.testing.expectEqualStrings(expected_preserved, w.buffer[w.end -| options.preserve..w.end]);

    try w.flush();

    try std.testing.expectEqualStrings(expected_out, fw.buffered());
}

test {
    _ = Limited;
}