core/bytes package | Odin Programming Language

alias #

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

alias returns true if and only if (⟺) 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 if and only if (⟺) 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: Error) {…}

buffer_read_at #

Source

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

buffer_read_byte #

Source

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

buffer_read_bytes #

Source

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

buffer_read_from #

Source

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

buffer_read_ptr #

Source

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

buffer_read_rune #

Source

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

buffer_read_slice #

Source

buffer_read_slice :: proc(b: ^Buffer, slice: $S/[]$T) -> (n: int, err: Error) {…}

buffer_read_string #

Source

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

buffer_reset #

Source

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

buffer_seek #

Source

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

buffer_to_bytes #

Source

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

buffer_to_stream #

Source

buffer_to_stream :: proc(b: ^Buffer) -> (s: 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) -> Error {…}

buffer_unread_rune #

Source

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

buffer_write #

Source

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

buffer_write_at #

Source

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

buffer_write_byte #

Source

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

buffer_write_ptr #

Source

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

buffer_write_rune #

Source

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

buffer_write_slice #

Source

buffer_write_slice :: proc(b: ^Buffer, slice: $S/[]$T, loc := #caller_location) -> (n: int, err: Error) {…}

buffer_write_string #

Source

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

buffer_write_to #

Source

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

center_justify #

Source

center_justify :: proc(str: []u8, length: int, pad: []u8, allocator := context.allocator, loc := #caller_location) -> []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

centre_justify #

Source

centre_justify :: proc(str: []u8, length: int, pad: []u8, allocator := context.allocator, loc := #caller_location) -> []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: Allocator_Error) {…}

compare #

Source

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

Compares two []byte, returning a value representing which one comes first lexiographically. Returns: -1 for `lhs`, 1 for `rhs`, or 0 if they are equal.

concatenate #

Source

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

concatenate_safe #

Source

concatenate_safe :: proc(a: [][]u8, allocator := context.allocator, loc := #caller_location) -> (data: []u8, err: 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, loc := #caller_location) -> []u8 {…}

fields #

Source

fields :: proc(s: []u8, allocator := context.allocator, loc := #caller_location) -> [][]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, loc := #caller_location) -> [][]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, loc := #caller_location) -> []u8 {…}

join_safe #

Source

join_safe :: proc(a: [][]u8, sep: []u8, allocator := context.allocator, loc := #caller_location) -> (data: []u8, err: 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, loc := #caller_location) -> []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 :: proc(str: []u8) -> ^u8 {…}

reader_init #

Source

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

reader_length #

Source

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

reader_read #

Source

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

reader_read_at #

Source

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

reader_read_byte #

Source

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

reader_read_ptr #

Source

reader_read_ptr :: proc(r: ^Reader, data: rawptr, len: int) -> (n: int, err: Error) {…}

reader_read_ptr_at #

Source

reader_read_ptr_at :: proc(r: ^Reader, data: rawptr, len: int, off: i64) -> (n: int, err: Error) {…}

reader_read_rune #

Source

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

reader_read_slice #

Source

reader_read_slice :: proc(r: ^Reader, slice: $T/[]$S) -> (n: int, err: Error) {…}

reader_read_slice_at #

Source

reader_read_slice_at :: proc(r: ^Reader, slice: $T/[]$S, off: i64) -> (n: int, err: Error) {…}

reader_seek #

Source

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

reader_size #

Source

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

reader_to_stream #

Source

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

reader_unread_byte #

Source

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

reader_unread_rune #

Source

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

reader_write_to #

Source

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

remove #

Source

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

remove_all #

Source

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

repeat #

Source

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

replace #

Source

replace :: proc(
	s, old, new: []u8, 
	n:           int, 
	allocator := context.allocator, 
	loc := #caller_location, 
) -> (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, loc := #caller_location) -> (output: []u8, was_allocation: bool) {…}

reverse #

Source

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

right_justify #

Source

right_justify :: proc(str: []u8, length: int, pad: []u8, allocator := context.allocator, loc := #caller_location) -> []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, loc := #caller_location) -> []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, loc := #caller_location) -> [][]u8 {…}

split_after #

Source

split_after :: proc(s, sep: []u8, allocator := context.allocator, loc := #caller_location) -> [][]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, loc := #caller_location) -> [][]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, loc := #caller_location) -> [][]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, loc := #caller_location) -> [][]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 {…}

Collection Info

Source Files