BinaryReader :: struct {
    stream: &Stream;
}

BinaryWriter :: struct {
    stream: &Stream;
}

BufferStream :: struct {
    stream: Stream;
    data: [..] u8;
    curr_pos: i32;
    write_enabled: bool;
    fixed: bool;
}

Reader :: struct {
    stream: &Stream;
    buffer: [] u8;
    buffer_allocator: Allocator;
    start: u32;
    end: u32;
    last_byte: i32;
    error: Error;
    done: bool;
    newline_format: NewLineFormat;
}

Stream :: struct {
    vtable: &Stream_Vtable;
    flags: Stream_Flags;
}

Stream_Vtable :: struct {
    seek: (&Stream, i32, SeekFrom) -> Error;
    tell: (&Stream) -> Result(u32, Error);
    read: (&Stream, [] u8) -> Result(u32, Error);
    read_at: (&Stream, u32, [] u8) -> Result(u32, Error);
    read_byte: (&Stream) -> Result(u8, Error);
    write: (&Stream, [] u8) -> Result(u32, Error);
    write_at: (&Stream, u32, [] u8) -> Result(u32, Error);
    write_byte: (&Stream, u8) -> Error;
    close: (&Stream) -> Error;
    flush: (&Stream) -> Error;
    size: (&Stream) -> i32;
    poll: (&Stream, PollEvent, i32) -> Result(bool, Error);
}

Writer :: struct {
    stream: &Stream;
    error: Error;
    buffer: [] u8;
    buffer_filled: u32;
}

Error :: enum {
    None :: 0;
    NotImplemented :: 1;
    EOF :: 2;
    NoVtable :: 3;
    OutOfBounds :: 4;
    NotFound :: 5;
    BadFile :: 6;
    BufferFull :: 7;
    NoProgress :: 8;
    InvalidUnread :: 9;
    ReadPending :: 10;
    ReadLater :: 11;
    ConnectFailed :: 12;
    NoData :: 13;
    CreationFailed :: 14;
    OperationFailed :: 15;
}

NewLineFormat :: enum {
    LF :: 0;
    CRLF :: 1;
}

PollEvent :: enum {
    None :: 0;
    Read :: 1;
    Write :: 2;
    Closed :: 3;
}

SeekFrom :: enum {
    Start :: 0;
    Current :: 1;
    End :: 2;
}

Stream_Flags :: enum #flags {
    Block_On_Read :: 1;
}

advance_line :: (reader: &Reader) -> void

binary_read :: (br: &BinaryReader, $T: type_expr) -> T

binary_read_byte :: (br: &BinaryReader) -> u8

binary_read_slice :: (br: &BinaryReader, $T: type_expr, size, read_size, allocator) -> [] T

binary_reader_make :: (s: &Stream) -> BinaryReader

binary_write :: (bw: &BinaryWriter, $T: type_expr, v: &T) -> void

binary_write_byte :: (bw: &BinaryWriter, byte: u8) -> void

binary_write_slice :: (bw: &BinaryWriter, sl: [] $T, output_size) -> void

binary_writer_make :: (s: &Stream) -> BinaryWriter

buffer_stream_free :: (bs: &BufferStream) -> void

buffer_stream_make :: (initial_data: [] u8, allocator: Allocator, fixed: bool, write_enabled: bool) -> BufferStream

buffer_stream_make :: (initial_size: i32, allocator: Allocator) -> BufferStream

buffer_stream_to_str :: (bs: &BufferStream) -> [] u8

lines :: (r: &Reader, inplace: bool, allocator: Allocator) -> Iterator([] u8)

peek_byte :: (reader: &Reader, advance: i32) -> (u8, Error)

read_all :: (reader: &Reader, allocator: Allocator) -> [] u8

read_byte :: (reader: &Reader) -> u8

read_bytes :: (reader: &Reader, bytes: [] u8) -> (i32, Error)

read_fill_buffer :: (reader: &Reader, bytes: [] u8) -> Error

read_i32 :: (reader: &Reader) -> i32

read_i64 :: (reader: &Reader) -> i64

read_line :: (reader: &Reader, consume_newline: bool, allocator: Allocator, inplace: bool) -> [] u8

read_string :: (reader: &Reader, bytes: i32, allocator: Allocator) -> [] u8

read_u32 :: (reader: &Reader) -> u32

read_u64 :: (reader: &Reader) -> u64

read_until :: (reader: &Reader, until: u8, skip: u32, allocator: Allocator, consume_end: bool, inplace: bool) -> [] u8

read_word :: (reader: &Reader, numeric_allowed: bool, allocator: Allocator, inplace: bool) -> [] u8

reader_empty :: (reader: &Reader) -> bool

reader_free :: (reader: &Reader) -> void

reader_from_string :: (s: [] u8) -> (Reader, &BufferStream)

reader_get_buffered :: (reader: &Reader) -> i32

reader_make :: (s: &Stream, buffer_size: i32, allocator: Allocator, newline_format: NewLineFormat) -> Reader

reader_reset :: (reader: &Reader) -> void

skip_bytes :: (reader: &Reader, bytes: u32) -> (i32, Error)

skip_whitespace :: (reader: &Reader) -> void

stream_close :: (s: &Stream) -> Error

stream_flush :: (s: &Stream) -> Error

stream_poll :: (s: &Stream, ev: PollEvent, timeout: i32) -> Result(bool, Error)

stream_read :: (s: &Stream, buffer: [] u8) -> Result(u32, Error)

stream_read_at :: (s: &Stream, at: u32, buffer: [] u8) -> Result(u32, Error)

stream_read_byte :: (s: &Stream) -> Result(u8, Error)

stream_read_until_full :: (s: &Stream, buffer: [] u8) -> Result(u32, Error)

stream_seek :: (s: &Stream, to: i32, whence: SeekFrom) -> Error

stream_size :: (s: &Stream) -> i32

stream_tell :: (s: &Stream) -> Result(u32, Error)

stream_write :: (s: &Stream, buffer: [] u8) -> Result(u32, Error)

stream_write_at :: (s: &Stream, at: u32, buffer: [] u8) -> Result(u32, Error)

stream_write_byte :: (s: &Stream, byte: u8) -> Error

string_builder :: (allocator: Allocator) -> (Writer, &BufferStream)

unread_byte :: (reader: &Reader) -> Error

write :: (writer: &Writer, s: [] u8) -> void

write :: (writer: &Writer, cs: [&] u8) -> void

write :: (writer: &Writer, n: i32, base: u32) -> void

write :: (writer: &Writer, f: f32) -> void

write :: (writer: &Writer, n: i64, base: u64) -> void

write :: (writer: &Writer, f: f64) -> void

write :: (writer: &Writer, b: bool) -> void

write :: (writer: &Writer, p: &void) -> void

write :: (writer: &Writer, r: range, sep: [] u8) -> void

write :: (writer: &Writer, format: [] u8, va: ..any) -> void

write :: macro (w: &Writer, a: $T) -> void

write_bool :: (writer: &Writer, b: bool) -> void

write_byte :: (writer: &Writer, byte: u8) -> void

write_cstr :: (writer: &Writer, cs: [&] u8) -> void

write_escaped_str :: (writer: &Writer, s: [] u8) -> void

write_f32 :: (writer: &Writer, f: f32) -> void

write_f64 :: (writer: &Writer, f: f64) -> void

write_format :: (writer: &Writer, format: [] u8, va: ..any) -> void

write_format_va :: (writer: &Writer, format: [] u8, va: [] any) -> void

write_i32 :: (writer: &Writer, n: i32, base: u32) -> void

write_i64 :: (writer: &Writer, n: i64, base: u64) -> void

write_ptr :: (writer: &Writer, p: &void) -> void

write_range :: (writer: &Writer, r: range, sep: [] u8) -> void

write_str :: (writer: &Writer, s: [] u8) -> void

writer_consume_error :: (w: &Writer) -> Error

writer_flush :: (w: &Writer) -> void

writer_free :: (w: &Writer) -> void

writer_make :: (s: &Stream, buffer_size: i32) -> Writer

writer_remaining_capacity :: (w: &Writer) -> u32