Stdlib/std.io/Read

Read

interface Read

The Read interface usesd to reading bytes from a resource.

Methods

pub fn read(self, buf: Bytes): int throws IoError

Read bytes from the source into the given buffer. Returns the number of bytes read.

pub fn read_to_end(self, buf: Bytes): int throws IoError

[src]

fn read_to_end(self, buf: Bytes): int throws IoError {
    let bytes = Bytes.new(len: 8192);
    let total_len = 0;
    loop {
        let n = try self.read(bytes);
        if (n == 0) {
            break;
        }
        total_len += n;
        buf.append(bytes.slice(0, n));
    }
    return total_len;
}

Read all bytes until EOF in this source, placing them into std.io.Bytes.

pub fn read_to_string(self): string throws IoError, Utf8Error

[src]

fn read_to_string(self): string throws IoError, Utf8Error {
    let buf = Bytes.new();
    try self.read_to_end(buf);
    return try string.from_utf8(buf);
}

Read all bytes until EOF in this source, returning them as a string.

pub fn read_exact(self, len: int): Bytes throws IoError

[src]

fn read_exact(self, len: int): Bytes throws IoError {
    let bytes = Bytes.new(len: 8192);
    let buf = Bytes.new();
    let remaining = len;
    while (remaining > 0) {
        if (remaining < bytes.len()) {
            bytes.trunc(remaining);
        }
        let n = try self.read(bytes);
        if (n == 0) {
            throw IoError.other("unexpected EOF");
        }
        buf.append(bytes.slice(0, n));
        remaining -= n;
    }
    return buf;
}

Read the exact number of bytes required.

pub fn to_read_close(self, f: |()|): ReadClose

[src]

fn to_read_close(self, f: |() throws IoError|): ReadClose {
    return ReadCloseFn { reader: self, close_fn: f };
}

Create a ReadClose interface from this Read interface with a close function.

pub fn to_nop_read_close(self): ReadClose

[src]

fn to_nop_read_close(self): ReadClose {
    return self.to_read_close(|| {});
}

Returns a ReadClose with a no-op close method wrapping this Read

pub fn take(self, limit: int): Read

[src]

fn take(self, limit: int): Read {
    return Take.new(self, limit);
}

Creates an Read which will read at most limit bytes from it.