package core:io
Source

⌘K
Ctrl+K
or
/

    Overview

    package io provides 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.

    Types

    Closer ¶
    Source

    Closer :: Stream

    Error ¶
    Source

    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/write 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

    Flusher ¶
    Source

    Flusher :: Stream

    Limited_Reader ¶
    Source

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

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

    Multi_Writer ¶
    Source

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

    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 :: 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 ¶
    Source

    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

    Seeker ¶
    Source

    Seeker :: Stream

    Stream ¶
    Source

    Stream :: struct {
	procedure: Stream_Proc,
	data:      rawptr,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Stream_Mode ¶
    Source

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

    Stream_Mode_Set ¶
    Source

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

    Stream_Proc ¶
    Source

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

    Tee_Reader ¶
    Source

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

    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

    Constants

    This section is empty.

    Variables

    This section is empty.

    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 IFF 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 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 ¶
    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.

    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 s. 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_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_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_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) {…}

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2024-12 (vendor "odin") Windows_amd64 @ 2024-12-17 21:11:01.000819700 +0000 UTC