package core:container/queue
Source

Types

Queue ¶
Source

Queue :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}
 

Dynamically resizable double-ended queue/ring-buffer

Constants

DEFAULT_CAPACITY ¶
Source

DEFAULT_CAPACITY :: 16

Variables

This section is empty.

Procedures

append_elem ¶
Source

append_elem :: push_back
 

Push an element to the back of the queue

append_elems ¶
Source

append_elems :: push_back_elems
 

Push multiple elements to the front of the queue

back ¶
Source

back :: proc "odin" (q: ^$Q/Queue($T)) -> $T {…}

back_ptr ¶
Source

back_ptr :: proc "odin" (q: ^$Q/Queue($T)) -> ^$T {…}

cap ¶
Source

cap :: proc "odin" (q: $Q/Queue($T)) -> int {…}
 

The current capacity of the queue

clear ¶
Source

clear :: proc "odin" (q: ^$Q/Queue($T)) {…}
 

Clear the contents of the queue

consume_back ¶
Source

consume_back :: proc "odin" (q: ^$Q/Queue($T), n: int, loc := #caller_location) {…}
 

Consume n elements from the back of the queue

consume_front ¶
Source

consume_front :: proc "odin" (q: ^$Q/Queue($T), n: int, loc := #caller_location) {…}
 

Consume n elements from the front of the queue

destroy ¶
Source

destroy :: proc "odin" (q: ^$Q/Queue($T)) {…}
 

Procedure to destroy a queue

front ¶
Source

front :: proc "odin" (q: ^$Q/Queue($T)) -> $T {…}

front_ptr ¶
Source

front_ptr :: proc "odin" (q: ^$Q/Queue($T)) -> ^$T {…}

get ¶
Source

get :: proc "odin" (q: ^$Q/Queue($T), #any_int i: int, loc := #caller_location) -> $T {…}

get_ptr ¶
Source

get_ptr :: proc "odin" (q: ^$Q/Queue($T), #any_int i: int, loc := #caller_location) -> ^$T {…}

init ¶
Source

init :: proc "odin" (q: ^$Q/Queue($T), capacity: int = DEFAULT_CAPACITY, allocator := context.allocator) -> bool {…}
 

Procedure to initialize a queue

init_from_slice ¶
Source

init_from_slice :: proc "odin" (q: ^$Q/Queue($T), backing: []$T) -> bool {…}
 

Procedure to initialize a queue from a fixed backing slice

len ¶
Source

len :: proc "odin" (q: $Q/Queue($T)) -> int {…}
 

The length of the queue

peek_back ¶
Source

peek_back :: proc "odin" (q: ^$Q/Queue($T), loc := #caller_location) -> ^$T {…}

peek_front ¶
Source

peek_front :: proc "odin" (q: ^$Q/Queue($T), loc := #caller_location) -> ^$T {…}

pop_back ¶
Source

pop_back :: proc "odin" (q: ^$Q/Queue($T), loc := #caller_location) -> (elem: $T) {…}
 

Pop an element from the back of the queue

pop_back_safe ¶
Source

pop_back_safe :: proc "odin" (q: ^$Q/Queue($T)) -> (elem: $T, ok: bool) {…}
 

Safely pop an element from the back of the queue

pop_front ¶
Source

pop_front :: proc "odin" (q: ^$Q/Queue($T), loc := #caller_location) -> (elem: $T) {…}
 

Pop an element from the front of the queue

pop_front_safe ¶
Source

pop_front_safe :: proc "odin" (q: ^$Q/Queue($T)) -> (elem: $T, ok: bool) {…}
 

Safely pop an element from the front of the queue

push_back ¶
Source

push_back :: proc "odin" (q: ^$Q/Queue($T), elem: $T) -> bool {…}
 

Push an element to the back of the queue

push_back_elems ¶
Source

push_back_elems :: proc "odin" (q: ^$Q/Queue($T), elems: ..$T) -> bool {…}
 

Push multiple elements to the front of the queue

push_front ¶
Source

push_front :: proc "odin" (q: ^$Q/Queue($T), elem: $T) -> bool {…}
 

Push an element to the front of the queue

reserve ¶
Source

reserve :: proc "odin" (q: ^$Q/Queue($T), capacity: int) -> bool {…}
 

Reserve enough space for at least the specified capacity

set ¶
Source

set :: proc "odin" (q: ^$Q/Queue($T), #any_int i: int, val: $T, loc := #caller_location) {…}

space ¶
Source

space :: proc "odin" (q: $Q/Queue($T)) -> int {…}
 

Remaining space in the queue (cap-len)

Procedure Groups

append ¶
Source

append :: proc{
	push_back,
	push_back_elems,
}

push ¶
Source

push :: proc{
	push_back,
	push_back_elems,
}

Source Files

Generation Information

Generated with odin version dev-2023-03 (vendor "odin") Windows_amd64 @ 2023-03-29 21:09:05.458772900 +0000 UTC