strio
strio provides string-related I/O operations, specifically to make efficient use
of memory while building strings incrementally. The main entry points to strio
are dynamic and fixed. 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 strio or bufio stream.
Index
Types
type stream;
Functions
fn appendrune(io::handle, rune) (size | io::error);
fn concat(io::handle, str...) (size | io::error);
fn dynamic() stream;
fn fixed([]u8) stream;
fn join(io::handle, str, str...) (size | io::error);
fn reset(*stream) void;
fn rjoin(io::handle, str, str...) (size | io::error);
fn string(*stream) str;
fn truncate(*stream) void;
Types
type stream
Show undocumented member
type stream = struct {
stream: io::stream,
buf: []u8,
};
Functions
fn appendrune
fn appendrune(out: io::handle, r: rune) (size | io::error);
Appends a rune to a stream.
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
strio stream, but it's generally more efficient if it is. Returns the number
of bytes written, or an error.
fn dynamic
fn dynamic() stream;
Creates a write-only string stream using an allocated buffer for storage, for
efficiently building strings.
Calling io::close on this stream will free the buffer.
fn fixed
fn fixed(in: []u8) stream;
Creates a write-only string stream using the provided buffer for storage.
The program aborts if writes would exceed the buffer's capacity. The stream
doesn't need 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 strio 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;
Resets the buffer's length to zero, but does not attempt to deallocate its
backing memory. Suitable for use both with fixed and dynamic streams.
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 strio 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;
Returns the current contents of the buffer as a string. Aborts the program if
invalid UTF-8 has been written to the buffer. The return value is borrowed
from the stream, and will be freed when the stream is closed. Use
strings::dup to extend its lifetime.
fn truncate
fn truncate(in: *stream) void;
Truncates the buffer, freeing memory associated with it and setting its
length to zero.