package core:bytes
Source

⌘K
Ctrl+K
or
/

    Overview

    Procedures for manipulation of []byte slices.

    Index

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

    This section is empty.

    Procedures (125)
    Procedure Groups (0)

    This section is empty.

    Types

    Buffer ¶
    Source · buffer.odin:13

    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.odin:6

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

    Related Procedures With Parameters

    Constants

    MIN_READ ¶
    Source · buffer.odin:6

    MIN_READ :: 512

    Variables

    This section is empty.

    Procedures

    alias ¶
    Source · bytes.odin:1472

    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 · bytes.odin:1488

    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.odin:75

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

    buffer_destroy ¶
    Source · buffer.odin:51

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

    buffer_grow ¶
    Source · buffer.odin:138

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

    buffer_init ¶
    Source · buffer.odin:30

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

    buffer_init_allocator ¶
    Source · buffer.odin:40

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

    buffer_init_string ¶
    Source · buffer.odin:35

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

    buffer_is_empty ¶
    Source · buffer.odin:67

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

    buffer_length ¶
    Source · buffer.odin:71

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

    buffer_next ¶
    Source · buffer.odin:220

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

    buffer_read ¶
    Source · buffer.odin:235

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

    buffer_read_at ¶
    Source · buffer.odin:262

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

    buffer_read_byte ¶
    Source · buffer.odin:280

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

    buffer_read_bytes ¶
    Source · buffer.odin:352

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

    buffer_read_from ¶
    Source · buffer.odin:393

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

    buffer_read_ptr ¶
    Source · buffer.odin:252

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

    buffer_read_rune ¶
    Source · buffer.odin:291

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

    buffer_read_slice ¶
    Source · buffer.odin:256

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

    buffer_read_string ¶
    Source · buffer.odin:365

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

    buffer_reset ¶
    Source · buffer.odin:79

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

    buffer_seek ¶
    Source · buffer.odin:330

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

    buffer_to_bytes ¶
    Source · buffer.odin:56

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

    buffer_to_stream ¶
    Source · buffer.odin:418

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

    buffer_to_string ¶
    Source · buffer.odin:60

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

    buffer_truncate ¶
    Source · buffer.odin:86

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

    buffer_unread_byte ¶
    Source · buffer.odin:308

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

    buffer_unread_rune ¶
    Source · buffer.odin:319

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

    buffer_write ¶
    Source · buffer.odin:166

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

    buffer_write_at ¶
    Source · buffer.odin:146

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

    buffer_write_byte ¶
    Source · buffer.odin:193

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

    buffer_write_ptr ¶
    Source · buffer.odin:175

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

    buffer_write_rune ¶
    Source · buffer.odin:203

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

    buffer_write_slice ¶
    Source · buffer.odin:179

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

    buffer_write_string ¶
    Source · buffer.odin:184

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

    buffer_write_to ¶
    Source · buffer.odin:371

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

    center_justify ¶
    Source · bytes.odin:1306

    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 · bytes.odin:1306

    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 · bytes.odin:37

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

    clone_safe ¶
    Source · bytes.odin:43

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

    compare ¶
    Source · bytes.odin:72

    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 · bytes.odin:204

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

    concatenate_safe ¶
    Source · bytes.odin:221

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

    contains ¶
    Source · bytes.odin:91

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

    contains_any ¶
    Source · bytes.odin:95

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

    contains_rune ¶
    Source · bytes.odin:82

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

    count ¶
    Source · bytes.odin:748

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

    equal ¶
    Source · bytes.odin:105

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

    equal_fold ¶
    Source · bytes.odin:109

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

    expand_tabs ¶
    Source · bytes.odin:1247

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

    fields ¶
    Source · bytes.odin:1387

    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 · bytes.odin:1443

    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 · bytes.odin:157

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

    has_suffix ¶
    Source · bytes.odin:161

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

    index ¶
    Source · bytes.odin:610

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

    index_any ¶
    Source · bytes.odin:708

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

    index_byte ¶
    Source · bytes.odin:349

    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 · bytes.odin:885

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

    index_proc_with_state ¶
    Source · bytes.odin:894

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

    index_rune ¶
    Source · bytes.odin:936

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

    is_ascii_space ¶
    Source · bytes.odin:856

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

    is_in_cutset ¶
    Source · bytes.odin:989

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

    is_null ¶
    Source · bytes.odin:881

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

    is_space ¶
    Source · bytes.odin:863

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

    join ¶
    Source · bytes.odin:166

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

    join_safe ¶
    Source · bytes.odin:185

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

    last_index ¶
    Source · bytes.odin:660

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

    last_index_any ¶
    Source · bytes.odin:731

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

    last_index_byte ¶
    Source · bytes.odin:484

    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 · bytes.odin:903

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

    last_index_proc_with_state ¶
    Source · bytes.odin:915

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

    left_justify ¶
    Source · bytes.odin:1326

    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 · bytes.odin:1290

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

    ptr_from_bytes ¶
    Source · bytes.odin:50

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

    ptr_from_slice ¶
    Source · bytes.odin:50

    ptr_from_slice :: ptr_from_bytes

    reader_init ¶
    Source · reader.odin:12

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

    reader_length ¶
    Source · reader.odin:25

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

    reader_read ¶
    Source · reader.odin:36

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

    reader_read_at ¶
    Source · reader.odin:48

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

    reader_read_byte ¶
    Source · reader.odin:85

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

    reader_read_ptr ¶
    Source · reader.odin:74

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

    reader_read_ptr_at ¶
    Source · reader.odin:79

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

    reader_read_rune ¶
    Source · reader.odin:102

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

    reader_read_slice ¶
    Source · reader.odin:64

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

    reader_read_slice_at ¶
    Source · reader.odin:69

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

    reader_seek ¶
    Source · reader.odin:127

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

    reader_size ¶
    Source · reader.odin:32

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

    reader_to_stream ¶
    Source · reader.odin:19

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

    reader_unread_byte ¶
    Source · reader.odin:94

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

    reader_unread_rune ¶
    Source · reader.odin:116

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

    reader_write_to ¶
    Source · reader.odin:147

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

    remove ¶
    Source · bytes.odin:845

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

    remove_all ¶
    Source · bytes.odin:849

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

    repeat ¶
    Source · bytes.odin:784

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

    replace ¶
    Source · bytes.odin:805

    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 · bytes.odin:800

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

    reverse ¶
    Source · bytes.odin:1232

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

    right_justify ¶
    Source · bytes.odin:1345

    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 · bytes.odin:100

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

    scrub ¶
    Source · bytes.odin:1199

    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 · bytes.odin:287

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

    split_after ¶
    Source · bytes.odin:295

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

    split_after_iterator ¶
    Source · bytes.odin:333

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

    split_after_n ¶
    Source · bytes.odin:299

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

    split_iterator ¶
    Source · bytes.odin:329

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

    split_multi ¶
    Source · bytes.odin:1064

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

    split_multi_iterator ¶
    Source · bytes.odin:1145

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

    split_n ¶
    Source · bytes.odin:291

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

    trim ¶
    Source · bytes.odin:1021

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

    trim_left ¶
    Source · bytes.odin:1003

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

    trim_left_null ¶
    Source · bytes.odin:1038

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

    trim_left_proc ¶
    Source · bytes.odin:927

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

    trim_left_proc_with_state ¶
    Source · bytes.odin:958

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

    trim_left_space ¶
    Source · bytes.odin:1025

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

    trim_null ¶
    Source · bytes.odin:1046

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

    trim_prefix ¶
    Source · bytes.odin:1050

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

    trim_right ¶
    Source · bytes.odin:1012

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

    trim_right_null ¶
    Source · bytes.odin:1042

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

    trim_right_proc ¶
    Source · bytes.odin:966

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

    trim_right_proc_with_state ¶
    Source · bytes.odin:977

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

    trim_right_space ¶
    Source · bytes.odin:1029

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

    trim_space ¶
    Source · bytes.odin:1033

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

    trim_suffix ¶
    Source · bytes.odin:1057

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

    truncate_to_byte ¶
    Source · bytes.odin:55

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

    truncate_to_rune ¶
    Source · bytes.odin:62

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

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2026-10 (vendor "odin") Windows_amd64 @ 2026-10-10 00:25:51.511820200 +0000 UTC