package core:io

⌘K
Ctrl+K
or
/

    Types

    Error ¶

    Error :: enum i32 {
    	// No Error
    	None           = 0, 
    	// EOF is the error returned by `read` when no more input is available
    	EOF, 
    	// Unexpected_EOF means that EOF was encountered in the middle of reading a fixed-sized block of data
    	Unexpected_EOF, 
    	// Short_Write means that a write accepted fewer bytes than requested but failed to return an explicit error
    	Short_Write, 
    	// Invalid_Write means that a write returned an impossible count
    	Invalid_Write, 
    	// Short_Buffer means that a read required a longer buffer than was provided
    	Short_Buffer, 
    	// No_Progress is returned by some implementations of `io.Reader` when many calls
    	// to `read` have failed to return any data or error.
    	// This is usually a sign of a broken `io.Reader` implementation
    	No_Progress, 
    	Invalid_Whence, 
    	Invalid_Offset, 
    	Invalid_Unread, 
    	Negative_Read, 
    	Negative_Write, 
    	Negative_Count, 
    	Buffer_Full, 
    	// Unknown means that an error has occurred but cannot be categorized
    	Unknown, 
    	// Empty is returned when a procedure has not been implemented for an io.Stream
    	Empty          = -1, 
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    Limited_Reader ¶

    Limited_Reader :: struct {
    	r: Stream,
    	// underlying reader
    	n: i64,
    }
     

    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.

    Related Procedures With Parameters

    Multi_Reader ¶

    Multi_Reader :: struct {
    	readers: [dynamic]Stream,
    }
    Related Procedures With Parameters

    Multi_Writer ¶

    Multi_Writer :: struct {
    	writers: [dynamic]Stream,
    }
    Related Procedures With Parameters

    Read_Closer ¶

    Read_Closer :: Stream

    Read_Write_Closer ¶

    Read_Write_Closer :: Stream

    Read_Write_Seeker ¶

    Read_Write_Seeker :: Stream

    Read_Writer ¶

    Read_Writer :: Stream

    Section_Reader ¶

    Section_Reader :: struct {
    	r:     Stream,
    	base:  i64,
    	off:   i64,
    	limit: i64,
    }
     

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

    Related Procedures With Parameters

    Seek_From ¶

    Seek_From :: enum int {
    	Start   = 0, // seek relative to the origin of the file
    	Current = 1, // seek relative to the current offset
    	End     = 2, // seek relative to the end
    }
     

    Seek whence values

    Related Procedures With Parameters

    Stream_Mode ¶

    Stream_Mode :: enum int {
    	Close, 
    	Flush, 
    	Read, 
    	Read_At, 
    	Write, 
    	Write_At, 
    	Seek, 
    	Size, 
    	Destroy, 
    	Query,    // query what modes are available
    }

    Stream_Mode_Set ¶

    Stream_Mode_Set :: distinct bit_set[Stream_Mode; i64]
    Related Procedures With Parameters
    Related Procedures With Returns

    Stream_Proc ¶

    Stream_Proc :: proc(stream_data: rawptr, mode: Stream_Mode, p: []u8, offset: i64, whence: Seek_From) -> (n: i64, err: Error)

    Tee_Reader ¶

    Tee_Reader :: struct {
    	r: Stream,
    	w: Stream,
    }
    Related Procedures With Parameters

    Write_Closer ¶

    Write_Closer :: Stream

    Write_Flush_Closer ¶

    Write_Flush_Closer :: Stream

    Write_Flusher ¶

    Write_Flusher :: Stream

    Write_Seeker ¶

    Write_Seeker :: Stream

    Constants

    This section is empty.

    Variables

    This section is empty.

    Procedures

    close ¶

    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 ¶

    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 ¶

    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 ¶

    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 IFF err == nil

    destroy ¶

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

    flush ¶

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

    limited_reader_init ¶

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

    limited_reader_to_reader ¶

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

    multi_reader_destroy ¶

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

    multi_reader_init ¶

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

    multi_writer_destroy ¶

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

    multi_writer_init ¶

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

    n_wrapper ¶

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

    query ¶

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

    query_utility ¶

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

    read ¶

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

    read reads up to len(p) bytes into s. 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 ¶

    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 ¶

    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 ¶

    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 ¶

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

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

    read_ptr ¶

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

    read_ptr_at ¶

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

    read_rune ¶

    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.

    section_reader_init ¶

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

    section_reader_to_stream ¶

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

    seek ¶

    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 ¶

    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 ¶

    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 ¶

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

    to_closer ¶

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

    to_flusher ¶

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

    to_read_closer ¶

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

    to_read_write_closer ¶

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

    to_read_write_seeker ¶

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

    to_read_writer ¶

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

    to_reader ¶

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

    to_reader_at ¶

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

    to_seeker ¶

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

    to_write_closer ¶

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

    to_write_flush_closer ¶

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

    to_write_flusher ¶

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

    to_write_seeker ¶

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

    to_writer ¶

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

    to_writer_at ¶

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

    write ¶

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

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

    write_at ¶

    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_byte ¶

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

    write_encoded_rune ¶

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

    write_escaped_rune ¶

    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 ¶

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

    write_f32 ¶

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

    write_f64 ¶

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

    write_i128 ¶

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

    write_i64 ¶

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

    write_int ¶

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

    write_ptr ¶

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

    write_ptr_at ¶

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

    write_quoted_rune ¶

    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 ¶

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

    write_rune ¶

    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_string ¶

    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_u128 ¶

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

    write_u64 ¶

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

    write_uint ¶

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

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2024-03 (vendor "odin") Windows_amd64 @ 2024-03-01 21:10:24.157896800 +0000 UTC