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

Source line 1

Fields

unlimited: *Reader
remaining: Limit
interface: Reader

std.Io.Reader.Limited.discard

function

Source line 52

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

Parameters

r: *Reader
limit: Limit

Errors

EndOfStream
ReadFailed

See the Reader implementation for detailed diagnostics.

std.Io.Reader.Limited.init

function

Source line 12

pub fn init(reader: *Reader, limit: Limit, buffer: []u8) Limited

Parameters

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

std.Io.Reader.Limited.Limit

alias

Source line 6

Alias of std.Io.Limit

std.Io.Reader.Limited.Limited

alias

Source line 1

Alias of std.Io.Reader.Limited

std.Io.Reader.Limited.Reader

alias

Source line 4

Alias of std.Io.Reader

std.Io.Reader.Limited.std

alias

Source line 3

Alias of std

std.Io.Reader.Limited.stream

function

Source line 28

fn stream(r: *Reader, w: *Writer, limit: Limit) Reader.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 orig_buf: [10]u8 = undefined;
    @memcpy(&orig_buf, "test bytes");
    var fixed: std.Io.Reader = .fixed(&orig_buf);

    var limit_buf: [1]u8 = undefined;
    var limited: std.Io.Reader.Limited = .init(&fixed, @fromBackingInt(@intCast(4)), &limit_buf);

    var result_buf: [10]u8 = undefined;
    var fixed_writer: std.Io.Writer = .fixed(&result_buf);
    const streamed = try limited.interface.stream(&fixed_writer, @fromBackingInt(@intCast(7)));

    try std.testing.expect(streamed == 4);
    try std.testing.expectEqualStrings("test", result_buf[0..streamed]);
}

std.Io.Reader.Limited.Writer

alias

Source line 5

Alias of std.Io.Writer

Source code

std/Io/Reader/Limited.zig

const Limited = @This();

const std = @import("../../std.zig");
const Reader = std.Io.Reader;
const Writer = std.Io.Writer;
const Limit = std.Io.Limit;

unlimited: *Reader,
remaining: Limit,
interface: Reader,

pub fn init(reader: *Reader, limit: Limit, buffer: []u8) Limited {
    return .{
        .unlimited = reader,
        .remaining = limit,
        .interface = .{
            .vtable = &.{
                .stream = stream,
                .discard = discard,
            },
            .buffer = buffer,
            .seek = 0,
            .end = 0,
        },
    };
}

fn stream(r: *Reader, w: *Writer, limit: Limit) Reader.StreamError!usize {
    const l: *Limited = @fieldParentPtr("interface", r);
    if (l.remaining == .nothing) return error.EndOfStream;
    const n = try l.unlimited.stream(w, limit.min(l.remaining));
    l.remaining = l.remaining.subtract(n).?;
    return n;
}

test stream {
    var orig_buf: [10]u8 = undefined;
    @memcpy(&orig_buf, "test bytes");
    var fixed: std.Io.Reader = .fixed(&orig_buf);

    var limit_buf: [1]u8 = undefined;
    var limited: std.Io.Reader.Limited = .init(&fixed, @fromBackingInt(@intCast(4)), &limit_buf);

    var result_buf: [10]u8 = undefined;
    var fixed_writer: std.Io.Writer = .fixed(&result_buf);
    const streamed = try limited.interface.stream(&fixed_writer, @fromBackingInt(@intCast(7)));

    try std.testing.expect(streamed == 4);
    try std.testing.expectEqualStrings("test", result_buf[0..streamed]);
}

fn discard(r: *Reader, limit: Limit) Reader.Error!usize {
    const l: *Limited = @fieldParentPtr("interface", r);
    if (l.remaining == .nothing) return error.EndOfStream;
    const n = try l.unlimited.discard(limit.min(l.remaining));
    l.remaining = l.remaining.subtract(n).?;
    return n;
}

test "end of stream, read, hit limit exactly" {
    var f: Reader = .fixed("i'm dying");
    var l = f.limited(.limited(4), &.{});
    const r = &l.interface;

    var buf: [2]u8 = undefined;
    try r.readSliceAll(&buf);
    try r.readSliceAll(&buf);
    try std.testing.expectError(error.EndOfStream, l.interface.readSliceAll(&buf));
}

test "end of stream, read, hit limit after partial read" {
    var f: Reader = .fixed("i'm dying");
    var l = f.limited(.limited(5), &.{});
    const r = &l.interface;

    var buf: [2]u8 = undefined;
    try r.readSliceAll(&buf);
    try r.readSliceAll(&buf);
    try std.testing.expectError(error.EndOfStream, l.interface.readSliceAll(&buf));
}

test "end of stream, discard, hit limit exactly" {
    var f: Reader = .fixed("i'm dying");
    var l = f.limited(.limited(4), &.{});
    const r = &l.interface;

    try r.discardAll(2);
    try r.discardAll(2);
    try std.testing.expectError(error.EndOfStream, l.interface.discardAll(2));
}

test "end of stream, discard, hit limit after partial read" {
    var f: Reader = .fixed("i'm dying");
    var l = f.limited(.limited(5), &.{});
    const r = &l.interface;

    try r.discardAll(2);
    try r.discardAll(2);
    try std.testing.expectError(error.EndOfStream, l.interface.discardAll(2));
}