memio
memio provides implementations of io::stream which can read from or write to byte slices. fixed uses a caller-supplied buffer for storage, while dynamic uses a dynamically allocated buffer which will grow instead of erroring when writing past the end of the buffer. All memio streams are seekable; the read-write head works the same way as an operating system file. You can access the contents of the buffer via buffer and string.
Additionally, memio provides string-related I/O operations. Each of the utility functions (e.g. appendrune) work correctly with any io::handle, but for efficiency reasons it is recommended that they are either a memio:: or bufio:: stream.
Index
Types
type flag = enum uint {
NONE = 0,
NONBLOCK = 1 << 0,
};
type stream = struct {
stream: io::stream,
flags: flag,
buf: []u8,
pos: size,
};
Functions
fn appendrune(out: io::handle, r: rune) (size | io::error);
fn borrowedread(st: *stream, amt: size) ([]u8 | io::EOF);
fn buffer(in: *stream) []u8;
fn concat(out: io::handle, strs: str...) (size | io::error);
fn dynamic(flags: flag = flag::NONE) stream;
fn dynamic_from(in: []u8, flags: flag = flag::NONE) stream;
fn fixed(in: []u8, flags: flag = flag::NONE) stream;
fn join(out: io::handle, delim: str, strs: str...) (size | io::error);
fn rconcat(out: io::handle, strs: str...) (size | io::error);
fn reset(in: *stream) void;
fn rjoin(out: io::handle, delim: str, strs: str...) (size | io::error);
fn string(in: *stream) (str | utf8::invalid);
Types
type flag
type flag = enum uint {
NONE = 0,
NONBLOCK = 1 << 0,
};
Flags for memio streams.
type stream
Show undocumented member
type stream = struct {
stream: io::stream,
flags: flag,
buf: []u8,
pos: size,
};
Functions
fn appendrune
fn appendrune(out: io::handle, r: rune) (size | io::error);
Appends a rune to a stream.
fn borrowedread
fn borrowedread(st: *stream, amt: size) ([]u8 | io::EOF);
Reads data from a dynamic or fixed stream and returns a slice borrowed from the internal buffer.
fn buffer
fn buffer(in: *stream) []u8;
Returns a stream's buffer, up to the current cursor position. io::seek to the end first in order to return the entire buffer. The return value is borrowed from the input.
fn concat
fn concat(out: io::handle, strs: str...) (size | io::error);
Appends zero or more strings to an io::handle. The output needn't be a memio stream, but it's generally more efficient if it is. Returns the number of bytes written, or an error.
fn dynamic
fn dynamic(flags: flag = flag::NONE) stream;
Creates an io::stream which dynamically allocates a buffer to store writes into. Seeking the stream and reading will read the written data. Calling io::close on this stream will free the buffer. If a stream's data is referenced via buffer, the stream shouldn't be closed as long as the data is used.
fn dynamic_from
fn dynamic_from(in: []u8, flags: flag = flag::NONE) stream;
Like dynamic, but takes an existing slice as input. Writes will overwrite the buffer and reads consume bytes from the initial buffer. Ownership of the provided slice is transferred to the returned stream. Calling io::close will free the buffer.
fn fixed
fn fixed(in: []u8, flags: flag = flag::NONE) stream;
Creates a stream for a fixed, caller-supplied buffer. Seeking a stream will cause subsequent writes to overwrite existing contents of the buffer. Writes return an error if they would exceed the buffer's capacity. The stream doesn't have to be closed.
fn join
fn join(out: io::handle, delim: str, strs: str...) (size | io::error);
Joins several strings together by a delimiter and writes them to a handle. The output needn't be a memio stream, but it's generally more efficient if it is. Returns the number of bytes written, or an error.
fn rconcat
fn rconcat(out: io::handle, strs: str...) (size | io::error);
Appends zero or more strings to an io::handle, in reverse order. The output needn't be a memio stream, but it's generally more efficient if it is. Returns the number of bytes written, or an error.
fn reset
fn reset(in: *stream) void;
A convenience function that sets the read-write cursor to zero, so that the buffer can be overwritten and reused.
fn rjoin
fn rjoin(out: io::handle, delim: str, strs: str...) (size | io::error);
Joins several strings together by a delimiter and writes them to a handle, in reverse order. The output needn't be a memio stream, but it's generally more efficient if it is. Returns the number of bytes written, or an error.
fn string
fn string(in: *stream) (str | utf8::invalid);
Returns a stream's buffer, up to the current cursor position, as a string. io::seek to the end first in order to return the entire buffer. The return value is borrowed from the input.