core/io package | Odin Programming Language

Basic interfaces for generic data stream primitives. The purpose of this package is wrap existing data structures and their operations into an abstracted stream interface.

Collection Info

View Source

Collection: core
Path: io
Entries: 96

Constants 0

Types 26

Jump to Types

Closer Error Flusher Limited_Reader Multi_Reader Multi_Writer Read_Closer Read_Write_Closer Read_Write_Seeker Read_Writer Reader Reader_At Section_Reader Seek_From Seeker Stream +10 more

Procedures 70

Jump to Procedures

close copy copy_buffer copy_n destroy flush limited_reader_init limited_reader_to_reader multi_reader_destroy multi_reader_init multi_writer_destroy multi_writer_init n_wrapper query query_utility read +54 more

Procedure Groups 0

Variables 0

Source Files

Types

Closer #

Source

Closer :: Stream

Error #

Source

Error :: Error

Flusher #

Source

Flusher :: Stream

Limited_Reader #

Source

Limited_Reader :: Limited_Reader

A Limited_Reader reads from r but limits the amount of data returned to just n bytes. Each call to read updates n to reflect the new amount remaining. read returns EOF when n <= 0 or when the underlying r returns EOF.

Multi_Reader #

Source

Multi_Reader :: Multi_Reader

Multi_Writer #

Source

Multi_Writer :: Multi_Writer

Read_Closer #

Source

Read_Closer :: Stream

Read_Write_Closer #

Source

Read_Write_Closer :: Stream

Read_Write_Seeker #

Source

Read_Write_Seeker :: Stream

Read_Writer #

Source

Read_Writer :: Stream

Reader #

Source

Reader :: Stream

Reader_At #

Source

Reader_At :: Stream

Section_Reader #

Source

Section_Reader :: Section_Reader

Section_Reader implements read, seek, and read_at on a section of an underlying Reader_At

Seek_From #

Source

Seek_From :: Seek_From

Seek whence values

Seeker #

Source

Seeker :: Stream

Stream #

Source

Stream :: Stream

Stream_Mode #

Source

Stream_Mode :: Stream_Mode

Stream_Mode_Set #

Source

Stream_Mode_Set :: distinct Stream_Mode_Set

Stream_Proc #

Source

Stream_Proc :: Stream_Proc

Tee_Reader #

Source

Tee_Reader :: Tee_Reader

Write_Closer #

Source

Write_Closer :: Stream

Write_Flush_Closer #

Source

Write_Flush_Closer :: Stream

Write_Flusher #

Source

Write_Flusher :: Stream

Write_Seeker #

Source

Write_Seeker :: Stream

Writer #

Source

Writer :: Stream

Writer_At #

Source

Writer_At :: Stream

Procedures

close #

Source

close :: proc(s: Stream) -> (err: Error) {…}

The behaviour of close after the first call is stream implementation defined. Different streams may document their own behaviour.

copy #

Source

copy :: proc(dst: Stream, src: Stream) -> (written: i64, err: Error) {…}

copy copies from src to dst till either EOF is reached on src or an error occurs It returns the number of bytes copied and the first error that occurred whilst copying, if any.

copy_buffer #

Source

copy_buffer :: proc(dst: Stream, src: Stream, buf: []u8) -> (written: i64, err: Error) {…}

copy_buffer is the same as copy except that it stages through the provided buffer (if one is required) rather than allocating a temporary one on the stack through `intrinsics.alloca` If buf is `nil`, it is allocate through `intrinsics.alloca`; otherwise if it has zero length, it will panic

copy_n #

Source

copy_n :: proc(dst: Stream, src: Stream, n: i64) -> (written: i64, err: Error) {…}

copy_n copies n bytes (or till an error) from src to dst. It returns the number of bytes copied and the first error that occurred whilst copying, if any. On return, written == n if and only if (⟺) err == nil

destroy #

Source

destroy :: proc(s: Stream) -> (err: Error) {…}

flush #

Source

flush :: proc(s: Stream) -> (err: Error) {…}

limited_reader_init #

Source

limited_reader_init :: proc(l: ^Limited_Reader, r: Stream, n: i64) -> Stream {…}

limited_reader_to_reader #

Source

limited_reader_to_reader :: proc(l: ^Limited_Reader) -> (r: Stream) {…}

multi_reader_destroy #

Source

multi_reader_destroy :: proc(mr: ^Multi_Reader) {…}

multi_reader_init #

Source

multi_reader_init :: proc(mr: ^Multi_Reader, readers: ..Stream, allocator := context.allocator) -> (r: Stream) {…}

multi_writer_destroy #

Source

multi_writer_destroy :: proc(mw: ^Multi_Writer) {…}

multi_writer_init #

Source

multi_writer_init :: proc(mw: ^Multi_Writer, writers: ..Stream, allocator := context.allocator) -> (out: Stream) {…}

n_wrapper #

Source

n_wrapper :: proc(n: int, err: Error, bytes_processed: ^int) -> Error {…}

query #

Source

query :: proc(s: Stream) -> (set: Stream_Mode_Set) {…}

query_utility #

Source

query_utility :: proc "contextless" (set: Stream_Mode_Set) -> (n: i64, err: Error) {…}

read #

Source

read :: proc(s: Stream, p: []u8, n_read: ^int = nil) -> (n: int, err: Error) {…}

read reads up to len(p) bytes into p. It returns the number of bytes read and any error if occurred. When read encounters an .EOF or error after successfully reading n > 0 bytes, it returns the number of bytes read along with the error.

read_at #

Source

read_at :: proc(r: Stream, p: []u8, offset: i64, n_read: ^int = nil) -> (n: int, err: Error) {…}

read_at reads len(p) bytes into p starting with the provided offset in the underlying Reader_At stream r. It returns the number of bytes read and any error if occurred. When read_at returns n < len(p), it returns a non-nil Error explaining why. If n == len(p), err may be either nil or .EOF

read_at_least #

Source

read_at_least :: proc(r: Stream, buf: []u8, min: int) -> (n: int, err: Error) {…}

read_at_least reads from r into buf until it has read at least min bytes. It returns the number of bytes copied and an error if fewer bytes were read. `.EOF` is only returned if no bytes were read. `.Unexpected_EOF` is returned when an `.EOF ` is returned by the passed Reader after reading fewer than min bytes. If len(buf) is less than min, `.Short_Buffer` is returned.

read_byte #

Source

read_byte :: proc(r: Stream, n_read: ^int = nil) -> (b: u8, err: Error) {…}

read_byte reads and returns the next byte from r.

read_full #

Source

read_full :: proc(r: Stream, buf: []u8) -> (n: int, err: Error) {…}

read_full expected exactly len(buf) bytes from r into buf.

read_ptr #

Source

read_ptr :: proc(r: Stream, p: rawptr, byte_size: int, n_read: ^int = nil) -> (n: int, err: Error) {…}

read_ptr_at #

Source

read_ptr_at :: proc(r: Stream, p: rawptr, byte_size: int, offset: i64, n_read: ^int = nil) -> (n: int, err: Error) {…}

read_rune #

Source

read_rune :: proc(br: Stream, n_read: ^int = nil) -> (ch: rune, size: int, err: Error) {…}

read_rune reads a single UTF-8 encoded Unicode codepoint and returns the rune and its size in bytes.

read_slice #

Source

read_slice :: proc(r: Stream, slice: $S/[]$T, n_read: ^int = nil) -> (n: int, err: Error) {…}

section_reader_init #

Source

section_reader_init :: proc(s: ^Section_Reader, r: Stream, off: i64, n: i64) -> Stream {…}

section_reader_to_stream #

Source

section_reader_to_stream :: proc(s: ^Section_Reader) -> (out: Stream) {…}

seek #

Source

seek :: proc(s: Stream, offset: i64, whence: Seek_From) -> (n: i64, err: Error) {…}

seek sets the offset of the next read or write to offset. .Start means seek relative to the origin of the file. .Current means seek relative to the current offset. .End means seek relative to the end. seek returns the new offset to the start of the file/stream, and any error if occurred.

size #

Source

size :: proc(s: Stream) -> (n: i64, err: Error) {…}

size returns the size of the stream. If the stream does not support querying its size, 0 will be returned.

tee_reader_init #

Source

tee_reader_init :: proc(t: ^Tee_Reader, r: Stream, w: Stream, allocator := context.allocator) -> Stream {…}

tee_reader_init returns a Reader that writes to 'w' what it reads from 'r' All reads from 'r' performed through it are matched with a corresponding write to 'w' There is no internal buffering done The write must complete before th read completes Any error encountered whilst writing is reported as a 'read' error tee_reader_init must call io.destroy when done with

tee_reader_to_reader #

Source

tee_reader_to_reader :: proc(t: ^Tee_Reader) -> (r: Stream) {…}

to_closer #

Source

to_closer :: proc(s: Stream) -> (c: Stream, ok: bool = true) #optional_ok {…}

to_flusher #

Source

to_flusher :: proc(s: Stream) -> (f: Stream, ok: bool = true) #optional_ok {…}

to_read_closer #

Source

to_read_closer :: proc(s: Stream) -> (r: Stream, ok: bool = true) #optional_ok {…}

to_read_write_closer #

Source

to_read_write_closer :: proc(s: Stream) -> (r: Stream, ok: bool = true) #optional_ok {…}

to_read_write_seeker #

Source

to_read_write_seeker :: proc(s: Stream) -> (r: Stream, ok: bool = true) #optional_ok {…}

to_read_writer #

Source

to_read_writer :: proc(s: Stream) -> (r: Stream, ok: bool = true) #optional_ok {…}

to_reader #

Source

to_reader :: proc(s: Stream) -> (r: Stream, ok: bool = true) #optional_ok {…}

to_reader_at #

Source

to_reader_at :: proc(s: Stream) -> (r: Stream, ok: bool = true) #optional_ok {…}

to_seeker #

Source

to_seeker :: proc(s: Stream) -> (seeker: Stream, ok: bool = true) #optional_ok {…}

to_write_closer #

Source

to_write_closer :: proc(s: Stream) -> (w: Stream, ok: bool = true) #optional_ok {…}

to_write_flush_closer #

Source

to_write_flush_closer :: proc(s: Stream) -> (w: Stream, ok: bool = true) #optional_ok {…}

to_write_flusher #

Source

to_write_flusher :: proc(s: Stream) -> (w: Stream, ok: bool = true) #optional_ok {…}

to_write_seeker #

Source

to_write_seeker :: proc(s: Stream) -> (w: Stream, ok: bool = true) #optional_ok {…}

to_writer #

Source

to_writer :: proc(s: Stream) -> (w: Stream, ok: bool = true) #optional_ok {…}

to_writer_at #

Source

to_writer_at :: proc(s: Stream) -> (w: Stream, ok: bool = true) #optional_ok {…}

write #

Source

write :: proc(s: Stream, p: []u8, n_written: ^int = nil) -> (n: int, err: Error) {…}

write writes up to len(p) bytes into p. It returns the number of bytes written and any error if occurred.

write_at #

Source

write_at :: proc(w: Stream, p: []u8, offset: i64, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_at writes len(p) bytes into p starting with the provided offset in the underlying Writer_At stream w. It returns the number of bytes written and any error if occurred. If write_at is writing to a Writer_At which has a seek offset, then write_at should not affect the underlying seek offset.

write_at_least #

Source

write_at_least :: proc(w: Stream, buf: []u8, min: int) -> (n: int, err: Error) {…}

write_at_least writes at least `buf[:min]` to the writer and returns the amount written. If an error occurs before writing everything it is returned.

write_byte #

Source

write_byte :: proc(w: Stream, c: u8, n_written: ^int = nil) -> Error {…}

write_encoded_rune #

Source

write_encoded_rune :: proc(w: Stream, r: rune, write_quote: bool = true, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_escaped_rune #

Source

write_escaped_rune :: proc(
	w:         Stream, 
	r:         rune, 
	quote:     u8, 
	html_safe: bool = false, 
	n_written: ^int = nil, 
	for_json:  bool = false, 
) -> (n: int, err: Error) {…}

write_f16 #

Source

write_f16 :: proc(w: Stream, val: f16, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_f32 #

Source

write_f32 :: proc(w: Stream, val: f32, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_f64 #

Source

write_f64 :: proc(w: Stream, val: f64, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_full #

Source

write_full :: proc(w: Stream, buf: []u8) -> (n: int, err: Error) {…}

write_full writes until the entire contents of `buf` has been written or an error occurs.

write_i128 #

Source

write_i128 :: proc(w: Stream, i: i128, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_i64 #

Source

write_i64 :: proc(w: Stream, i: i64, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_int #

Source

write_int :: proc(w: Stream, i: int, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_ptr #

Source

write_ptr :: proc(w: Stream, p: rawptr, byte_size: int, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_ptr_at #

Source

write_ptr_at :: proc(w: Stream, p: rawptr, byte_size: int, offset: i64, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_quoted_rune #

Source

write_quoted_rune :: proc(w: Stream, r: rune) -> (n: int) {…}

writer append a quoted rune into the byte buffer, return the written size

write_quoted_string #

Source

write_quoted_string :: proc(w: Stream, str: string, quote: u8 = '"', n_written: ^int = nil, for_json: bool = false) -> (n: int, err: Error) {…}

write_quoted_string16 #

Source

write_quoted_string16 :: proc(w: Stream, str: string16, quote: u8 = '"', n_written: ^int = nil, for_json: bool = false) -> (n: int, err: Error) {…}

write_rune #

Source

write_rune :: proc(s: Stream, r: rune, n_written: ^int = nil) -> (size: int, err: Error) {…}

write_rune writes a UTF-8 encoded rune to w.

write_slice #

Source

write_slice :: proc(w: Stream, slice: $S/[]$T, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_string #

Source

write_string :: proc(s: Stream, str: string, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_string writes the contents of the string s to w.

write_string16 #

Source

write_string16 :: proc(s: Stream, str: string16, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_string16 writes the contents of the string16 s to w reencoded as utf-8

write_u128 #

Source

write_u128 :: proc(w: Stream, i: u128, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_u64 #

Source

write_u64 :: proc(w: Stream, i: u64, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {…}

write_uint #

Source

write_uint :: proc(w: Stream, i: uint, base: int = 10, n_written: ^int = nil) -> (n: int, err: Error) {…}