io #
Description:
io
provides common interfaces for buffered reading/writing of data.
fn cp #
fn cp(mut src Reader, mut dst Writer) ?
fn make_readerwriter #
fn make_readerwriter(r Reader, w Writer) ReaderWriterImpl
make_readerwriter takes a rstream and a wstream and makes an rwstream with them
fn new_buffered_reader #
fn new_buffered_reader(o BufferedReaderConfig) &BufferedReader
new_buffered_reader creates new BufferedReader
fn new_multi_writer #
fn new_multi_writer(writers ...Writer) Writer
new_multi_writer returns a Writer that writes to all writers. The write function of the returned Writer writes to all writers of the MultiWriter, returns the length of bytes written, and if any writer fails to write the full length an error is returned and writing to other writers stops, and if any writer returns an error the error is returned immediately and writing to other writers stops.
fn read_all #
fn read_all(config ReadAllConfig) ?[]u8
read_all reads all bytes from a reader until either a 0 length read or if read_to_end_of_stream is true then the end of the stream (none
)
fn read_any #
fn read_any(mut r Reader) ?[]u8
read_any reads any available bytes from a reader (until the reader returns a read of 0 length)
interface RandomReader #
interface RandomReader {
read_from(pos u64, mut buf []u8) ?int
}
RandomReader represents a stream of data that can be read from at a random location
interface RandomWriter #
interface RandomWriter {
write_to(pos u64, buf []u8) ?int
}
RandomWriter represents a stream of data that can be wrote to at a random pos
interface Reader #
interface Reader {
// read reads up to buf.len bytes and places
// them into buf.
// A type that implements this should return
// `none` on end of stream (EOF) instead of just returning 0
mut:
read(mut buf []u8) ?int
}
Reader represents a stream of data that can be read
interface ReaderWriter #
interface ReaderWriter {
Reader
Writer
}
ReaderWriter represents a stream that can be read from and wrote to
interface Writer #
interface Writer {
mut:
write(buf []u8) ?int
}
Writer represents a stream of data that can be wrote to
fn (BufferedReader) read #
fn (mut r BufferedReader) read(mut buf []u8) ?int
read fufills the Reader interface
fn (BufferedReader) free #
fn (mut r BufferedReader) free()
fn (BufferedReader) end_of_stream #
fn (r BufferedReader) end_of_stream() bool
end_of_stream returns whether the end of the stream was reached
fn (BufferedReader) read_line #
fn (mut r BufferedReader) read_line() ?string
read_line attempts to read a line from the buffered reader it will read until it finds a new line character (\n) or the end of stream
fn (ReaderWriterImpl) read #
fn (mut r ReaderWriterImpl) read(mut buf []u8) ?int
fn (ReaderWriterImpl) write #
fn (mut r ReaderWriterImpl) write(buf []u8) ?int
struct BufferedReaderConfig #
struct BufferedReaderConfig {
reader Reader
cap int = 128 * 1024 // large for fast reading of big(ish) files
retries int = 2 // how many times to retry before assuming the stream ended
}
BufferedReaderConfig are options that can be given to a reader
struct MultiWriter #
struct MultiWriter {
pub mut:
writers []Writer
}
MultiWriter writes to all its writers.
fn (MultiWriter) write #
fn (mut m MultiWriter) write(buf []u8) ?int
write writes to all writers of the MultiWriter. Returns the length of bytes written. If any writer fails to write the full length an error is returned and writing to other writers stops. If any writer returns an error the error is returned immediately and writing to other writers stops.
struct ReadAllConfig #
struct ReadAllConfig {
read_to_end_of_stream bool
mut:
reader Reader
}
ReadAllConfig allows options to be passed for the behaviour of read_all
- README
- fn cp
- fn make_readerwriter
- fn new_buffered_reader
- fn new_multi_writer
- fn read_all
- fn read_any
- interface RandomReader
- interface RandomWriter
- interface Reader
- interface ReaderWriter
- interface Writer
- type BufferedReader
- type ReaderWriterImpl
- struct BufferedReaderConfig
- struct MultiWriter
- struct ReadAllConfig