package core:bytes
Source

⌘K
Ctrl+K
or
/

    Index

    Types (2)
    Constants (1)
    Variables (0)

    This section is empty.

    Procedures (119)
    Procedure Groups (0)

    This section is empty.

    Types

    Buffer ¶
    Source

    Buffer :: struct {
	buf:       [dynamic]u8,
	off:       int,
	last_read: Read_Op,
}
     

    A Buffer is a variable-sized buffer of bytes with a io.Stream interface The zero value for Buffer is an empty buffer ready to use.

    Related Procedures With Parameters

    Reader ¶
    Source

    Reader :: struct {
	s:         []u8,
	// read-only buffer
	i:         i64,
	// current reading index
	prev_rune: int,
}
    Related Procedures With Parameters

    Constants

    MIN_READ ¶
    Source

    MIN_READ :: 512

    Variables

    This section is empty.

    Procedures

    alias ¶
    Source

    alias :: proc "contextless" (a, b: []u8) -> bool {…}
     

    alias returns true iff a and b have a non-zero length, and any part of a overlaps with b.

    alias_inexactly ¶
    Source

    alias_inexactly :: proc "contextless" (a, b: []u8) -> bool {…}
     

    alias_inexactly returns true iff a and b have a non-zero length, the base pointer of a and b are NOT equal, and any part of a overlaps with b (ie: alias(a, b) with an exception that returns false for a == b, b = a[:len(a)-69] and similar conditions).

    buffer_capacity ¶
    Source

    buffer_capacity :: proc(b: ^Buffer) -> int {…}

    buffer_destroy ¶
    Source

    buffer_destroy :: proc(b: ^Buffer) {…}

    buffer_grow ¶
    Source

    buffer_grow :: proc(b: ^Buffer, n: int, loc := #caller_location) {…}

    buffer_init ¶
    Source

    buffer_init :: proc(b: ^Buffer, buf: []u8, loc := #caller_location) {…}

    buffer_init_allocator ¶
    Source

    buffer_init_allocator :: proc(b: ^Buffer, len, cap: int, allocator := context.allocator, loc := #caller_location) {…}

    buffer_init_string ¶
    Source

    buffer_init_string :: proc(b: ^Buffer, s: string, loc := #caller_location) {…}

    buffer_is_empty ¶
    Source

    buffer_is_empty :: proc(b: ^Buffer) -> bool {…}

    buffer_length ¶
    Source

    buffer_length :: proc(b: ^Buffer) -> int {…}

    buffer_next ¶
    Source

    buffer_next :: proc(b: ^Buffer, n: int) -> []u8 {…}

    buffer_read ¶
    Source

    buffer_read :: proc(b: ^Buffer, p: []u8) -> (n: int, err: io.Error) {…}

    buffer_read_at ¶
    Source

    buffer_read_at :: proc(b: ^Buffer, p: []u8, offset: int) -> (n: int, err: io.Error) {…}

    buffer_read_byte ¶
    Source

    buffer_read_byte :: proc(b: ^Buffer) -> (u8, io.Error) {…}

    buffer_read_bytes ¶
    Source

    buffer_read_bytes :: proc(b: ^Buffer, delim: u8) -> (line: []u8, err: io.Error) {…}

    buffer_read_from ¶
    Source

    buffer_read_from :: proc(b: ^Buffer, r: io.Stream) -> (n: i64, err: io.Error) {…}

    buffer_read_ptr ¶
    Source

    buffer_read_ptr :: proc(b: ^Buffer, ptr: rawptr, size: int) -> (n: int, err: io.Error) {…}

    buffer_read_rune ¶
    Source

    buffer_read_rune :: proc(b: ^Buffer) -> (r: rune, size: int, err: io.Error) {…}

    buffer_read_string ¶
    Source

    buffer_read_string :: proc(b: ^Buffer, delim: u8) -> (line: string, err: io.Error) {…}

    buffer_reset ¶
    Source

    buffer_reset :: proc(b: ^Buffer) {…}

    buffer_seek ¶
    Source

    buffer_seek :: proc(b: ^Buffer, offset: i64, whence: io.Seek_From) -> (i64, io.Error) {…}

    buffer_to_bytes ¶
    Source

    buffer_to_bytes :: proc(b: ^Buffer) -> []u8 {…}

    buffer_to_stream ¶
    Source

    buffer_to_stream :: proc(b: ^Buffer) -> (s: io.Stream) {…}

    buffer_to_string ¶
    Source

    buffer_to_string :: proc(b: ^Buffer) -> string {…}

    buffer_truncate ¶
    Source

    buffer_truncate :: proc(b: ^Buffer, n: int) {…}

    buffer_unread_byte ¶
    Source

    buffer_unread_byte :: proc(b: ^Buffer) -> io.Error {…}

    buffer_unread_rune ¶
    Source

    buffer_unread_rune :: proc(b: ^Buffer) -> io.Error {…}

    buffer_write ¶
    Source

    buffer_write :: proc(b: ^Buffer, p: []u8, loc := #caller_location) -> (n: int, err: io.Error) {…}

    buffer_write_at ¶
    Source

    buffer_write_at :: proc(b: ^Buffer, p: []u8, offset: int, loc := #caller_location) -> (n: int, err: io.Error) {…}

    buffer_write_byte ¶
    Source

    buffer_write_byte :: proc(b: ^Buffer, c: u8, loc := #caller_location) -> io.Error {…}

    buffer_write_ptr ¶
    Source

    buffer_write_ptr :: proc(b: ^Buffer, ptr: rawptr, size: int, loc := #caller_location) -> (n: int, err: io.Error) {…}

    buffer_write_rune ¶
    Source

    buffer_write_rune :: proc(b: ^Buffer, r: rune, loc := #caller_location) -> (n: int, err: io.Error) {…}

    buffer_write_string ¶
    Source

    buffer_write_string :: proc(b: ^Buffer, s: string, loc := #caller_location) -> (n: int, err: io.Error) {…}

    buffer_write_to ¶
    Source

    buffer_write_to :: proc(b: ^Buffer, w: io.Stream) -> (n: i64, err: io.Error) {…}

    center_justify ¶
    Source

    center_justify :: centre_justify
     

    centre_justify returns a byte slice with a pad byte slice at boths sides if the str's rune length is smaller than length

    centre_justify ¶
    Source

    centre_justify :: proc(str: []u8, length: int, pad: []u8, allocator := context.allocator) -> []u8 {…}
     

    centre_justify returns a byte slice with a pad byte slice at boths sides if the str's rune length is smaller than length

    clone ¶
    Source

    clone :: proc(s: []u8, allocator := context.allocator, loc := #caller_location) -> []u8 {…}

    clone_safe ¶
    Source

    clone_safe :: proc(s: []u8, allocator := context.allocator, loc := #caller_location) -> (data: []u8, err: runtime.Allocator_Error) {…}

    compare ¶
    Source

    compare :: proc(lhs, rhs: []u8) -> int {…}
     

    Compares two strings, returning a value representing which one comes first lexiographically. -1 for a; 1 for b, or 0 if they are equal.

    concatenate ¶
    Source

    concatenate :: proc(a: [][]u8, allocator := context.allocator) -> []u8 {…}

    concatenate_safe ¶
    Source

    concatenate_safe :: proc(a: [][]u8, allocator := context.allocator) -> (data: []u8, err: runtime.Allocator_Error) {…}

    contains ¶
    Source

    contains :: proc(s, substr: []u8) -> bool {…}

    contains_any ¶
    Source

    contains_any :: proc(s, chars: []u8) -> bool {…}

    contains_rune ¶
    Source

    contains_rune :: proc(s: []u8, r: rune) -> int {…}

    count ¶
    Source

    count :: proc(s, substr: []u8) -> int {…}

    equal ¶
    Source

    equal :: proc(a, b: []u8) -> bool {…}

    equal_fold ¶
    Source

    equal_fold :: proc(u, v: []u8) -> bool {…}

    expand_tabs ¶
    Source

    expand_tabs :: proc(s: []u8, tab_size: int, allocator := context.allocator) -> []u8 {…}

    fields ¶
    Source

    fields :: proc(s: []u8, allocator := context.allocator) -> [][]u8 {…}
     

    fields splits the byte slice s around each instance of one or more consecutive white space character, defined by unicode.is_space returning a slice of subslices of s or an empty slice if s only contains white space

    fields_proc ¶
    Source

    fields_proc :: proc(s: []u8, f: proc(rune) -> bool, allocator := context.allocator) -> [][]u8 {…}
     

    fields_proc splits the byte slice s at each run of unicode code points ch satisfying f(ch) returns a slice of subslices of s If all code points in s satisfy f(ch) or string is empty, an empty slice is returned

    fields_proc makes no guarantee about the order in which it calls f(ch) it assumes that f always returns the same value for a given ch

    has_prefix ¶
    Source

    has_prefix :: proc(s, prefix: []u8) -> bool {…}

    has_suffix ¶
    Source

    has_suffix :: proc(s, suffix: []u8) -> bool {…}

    index ¶
    Source

    index :: proc(s, substr: []u8) -> int {…}

    index_any ¶
    Source

    index_any :: proc(s, chars: []u8) -> int {…}

    index_byte ¶
    Source

    index_byte :: proc "contextless" (s: []u8, c: u8) -> (index: int) {…}
     

    Scan a slice of bytes for a specific byte.

    This procedure safely handles slices of any length, including empty slices.

    Inputs:
    data: A slice of bytes. c: The byte to search for.

    Returns:
    index: The index of the byte c, or -1 if it was not found.

    index_proc ¶
    Source

    index_proc :: proc(s: []u8, p: proc(rune) -> bool, truth: bool = true) -> int {…}

    index_proc_with_state ¶
    Source

    index_proc_with_state :: proc(s: []u8, p: proc(rawptr, rune) -> bool, state: rawptr, truth: bool = true) -> int {…}

    index_rune ¶
    Source

    index_rune :: proc(s: []u8, r: rune) -> int {…}

    is_ascii_space ¶
    Source

    is_ascii_space :: proc(r: rune) -> bool {…}

    is_in_cutset ¶
    Source

    is_in_cutset :: proc(state: rawptr, r: rune) -> bool {…}

    is_null ¶
    Source

    is_null :: proc(r: rune) -> bool {…}

    is_space ¶
    Source

    is_space :: proc(r: rune) -> bool {…}

    join ¶
    Source

    join :: proc(a: [][]u8, sep: []u8, allocator := context.allocator) -> []u8 {…}

    join_safe ¶
    Source

    join_safe :: proc(a: [][]u8, sep: []u8, allocator := context.allocator) -> (data: []u8, err: runtime.Allocator_Error) {…}

    last_index ¶
    Source

    last_index :: proc(s, substr: []u8) -> int {…}

    last_index_any ¶
    Source

    last_index_any :: proc(s, chars: []u8) -> int {…}

    last_index_byte ¶
    Source

    last_index_byte :: proc "contextless" (s: []u8, c: u8) -> int {…}
     

    Scan a slice of bytes for a specific byte, starting from the end and working backwards to the start.

    This procedure safely handles slices of any length, including empty slices.

    Inputs:
    data: A slice of bytes. c: The byte to search for.

    Returns:
    index: The index of the byte c, or -1 if it was not found.

    last_index_proc ¶
    Source

    last_index_proc :: proc(s: []u8, p: proc(rune) -> bool, truth: bool = true) -> int {…}

    last_index_proc_with_state ¶
    Source

    last_index_proc_with_state :: proc(s: []u8, p: proc(rawptr, rune) -> bool, state: rawptr, truth: bool = true) -> int {…}

    left_justify ¶
    Source

    left_justify :: proc(str: []u8, length: int, pad: []u8, allocator := context.allocator) -> []u8 {…}
     

    left_justify returns a byte slice with a pad byte slice at left side if the str's rune length is smaller than length

    partition ¶
    Source

    partition :: proc(str, sep: []u8) -> (head, match, tail: []u8) {…}

    ptr_from_bytes ¶
    Source

    ptr_from_bytes :: proc(str: []u8) -> ^u8 {…}

    ptr_from_slice ¶
    Source

    ptr_from_slice :: ptr_from_bytes

    reader_init ¶
    Source

    reader_init :: proc(r: ^Reader, s: []u8) -> io.Stream {…}

    reader_length ¶
    Source

    reader_length :: proc(r: ^Reader) -> int {…}

    reader_read ¶
    Source

    reader_read :: proc(r: ^Reader, p: []u8) -> (n: int, err: io.Error) {…}

    reader_read_at ¶
    Source

    reader_read_at :: proc(r: ^Reader, p: []u8, off: i64) -> (n: int, err: io.Error) {…}

    reader_read_byte ¶
    Source

    reader_read_byte :: proc(r: ^Reader) -> (u8, io.Error) {…}

    reader_read_rune ¶
    Source

    reader_read_rune :: proc(r: ^Reader) -> (ch: rune, size: int, err: io.Error) {…}

    reader_seek ¶
    Source

    reader_seek :: proc(r: ^Reader, offset: i64, whence: io.Seek_From) -> (i64, io.Error) {…}

    reader_size ¶
    Source

    reader_size :: proc(r: ^Reader) -> i64 {…}

    reader_to_stream ¶
    Source

    reader_to_stream :: proc(r: ^Reader) -> (s: io.Stream) {…}

    reader_unread_byte ¶
    Source

    reader_unread_byte :: proc(r: ^Reader) -> io.Error {…}

    reader_unread_rune ¶
    Source

    reader_unread_rune :: proc(r: ^Reader) -> io.Error {…}

    reader_write_to ¶
    Source

    reader_write_to :: proc(r: ^Reader, w: io.Stream) -> (n: i64, err: io.Error) {…}

    remove ¶
    Source

    remove :: proc(s, key: []u8, n: int, allocator := context.allocator) -> (output: []u8, was_allocation: bool) {…}

    remove_all ¶
    Source

    remove_all :: proc(s, key: []u8, allocator := context.allocator) -> (output: []u8, was_allocation: bool) {…}

    repeat ¶
    Source

    repeat :: proc(s: []u8, count: int, allocator := context.allocator) -> []u8 {…}

    replace ¶
    Source

    replace :: proc(s, old, new: []u8, n: int, allocator := context.allocator) -> (output: []u8, was_allocation: bool) {…}
     

    if n < 0, no limit on the number of replacements

    replace_all ¶
    Source

    replace_all :: proc(s, old, new: []u8, allocator := context.allocator) -> (output: []u8, was_allocation: bool) {…}

    reverse ¶
    Source

    reverse :: proc(s: []u8, allocator := context.allocator) -> []u8 {…}

    right_justify ¶
    Source

    right_justify :: proc(str: []u8, length: int, pad: []u8, allocator := context.allocator) -> []u8 {…}
     

    right_justify returns a byte slice with a pad byte slice at right side if the str's rune length is smaller than length

    rune_count ¶
    Source

    rune_count :: proc(s: []u8) -> int {…}

    scrub ¶
    Source

    scrub :: proc(s: []u8, replacement: []u8, allocator := context.allocator) -> []u8 {…}
     

    Scrubs invalid utf-8 characters and replaces them with the replacement string Adjacent invalid bytes are only replaced once

    split ¶
    Source

    split :: proc(s, sep: []u8, allocator := context.allocator) -> [][]u8 {…}

    split_after ¶
    Source

    split_after :: proc(s, sep: []u8, allocator := context.allocator) -> [][]u8 {…}

    split_after_iterator ¶
    Source

    split_after_iterator :: proc(s: ^[]u8, sep: []u8) -> ([]u8, bool) {…}

    split_after_n ¶
    Source

    split_after_n :: proc(s, sep: []u8, n: int, allocator := context.allocator) -> [][]u8 {…}

    split_iterator ¶
    Source

    split_iterator :: proc(s: ^[]u8, sep: []u8) -> ([]u8, bool) {…}

    split_multi ¶
    Source

    split_multi :: proc(s: []u8, substrs: [][]u8, skip_empty: bool = false, allocator := context.allocator) -> [][]u8 {…}

    split_multi_iterator ¶
    Source

    split_multi_iterator :: proc(s: ^[]u8, substrs: [][]u8, skip_empty: bool = false) -> ([]u8, bool) {…}

    split_n ¶
    Source

    split_n :: proc(s, sep: []u8, n: int, allocator := context.allocator) -> [][]u8 {…}

    trim ¶
    Source

    trim :: proc(s: []u8, cutset: []u8) -> []u8 {…}

    trim_left ¶
    Source

    trim_left :: proc(s: []u8, cutset: []u8) -> []u8 {…}

    trim_left_null ¶
    Source

    trim_left_null :: proc(s: []u8) -> []u8 {…}

    trim_left_proc ¶
    Source

    trim_left_proc :: proc(s: []u8, p: proc(rune) -> bool) -> []u8 {…}

    trim_left_proc_with_state ¶
    Source

    trim_left_proc_with_state :: proc(s: []u8, p: proc(rawptr, rune) -> bool, state: rawptr) -> []u8 {…}

    trim_left_space ¶
    Source

    trim_left_space :: proc(s: []u8) -> []u8 {…}

    trim_null ¶
    Source

    trim_null :: proc(s: []u8) -> []u8 {…}

    trim_prefix ¶
    Source

    trim_prefix :: proc(s, prefix: []u8) -> []u8 {…}

    trim_right ¶
    Source

    trim_right :: proc(s: []u8, cutset: []u8) -> []u8 {…}

    trim_right_null ¶
    Source

    trim_right_null :: proc(s: []u8) -> []u8 {…}

    trim_right_proc ¶
    Source

    trim_right_proc :: proc(s: []u8, p: proc(rune) -> bool) -> []u8 {…}

    trim_right_proc_with_state ¶
    Source

    trim_right_proc_with_state :: proc(s: []u8, p: proc(rawptr, rune) -> bool, state: rawptr) -> []u8 {…}

    trim_right_space ¶
    Source

    trim_right_space :: proc(s: []u8) -> []u8 {…}

    trim_space ¶
    Source

    trim_space :: proc(s: []u8) -> []u8 {…}

    trim_suffix ¶
    Source

    trim_suffix :: proc(s, suffix: []u8) -> []u8 {…}

    truncate_to_byte ¶
    Source

    truncate_to_byte :: proc(str: []u8, b: u8) -> []u8 {…}

    truncate_to_rune ¶
    Source

    truncate_to_rune :: proc(str: []u8, r: rune) -> []u8 {…}

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2024-11 (vendor "odin") Windows_amd64 @ 2024-11-16 21:10:09.755467700 +0000 UTC