package core:container/queue
Source

⌘K
Ctrl+K
or
/

    Types

    Queue ¶
    Source

    Queue :: struct($T: typeid) {
	… // See source for fields
}
     

    Dynamically resizable double-ended queue/ring-buffer

    Related Procedures With Parameters

    Constants

    DEFAULT_CAPACITY ¶
    Source

    DEFAULT_CAPACITY: int : 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 back of the queue

    back ¶
    Source

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

    back_ptr ¶
    Source

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

    cap ¶
    Source

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

    The current capacity of the queue

    clear ¶
    Source

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

    Clear the contents of the queue

    consume_back ¶
    Source

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

    Consume n elements from the back of the queue

    consume_front ¶
    Source

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

    Consume n elements from the front of the queue

    destroy ¶
    Source

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

    Procedure to destroy a queue

    front ¶
    Source

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

    front_ptr ¶
    Source

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

    get ¶
    Source

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

    get_ptr ¶
    Source

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

    init ¶
    Source

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

    Procedure to initialize a queue

    init_from_slice ¶
    Source

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

    Procedure to initialize a queue from a fixed backing slice. The contents of the backing will be overwritten as items are pushed onto the Queue. Any previous contents are not available.

    init_with_contents ¶
    Source

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

    Procedure to initialize a queue from a fixed backing slice. Existing contents are preserved and available on the queue.

    len ¶
    Source

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

    The length of the queue

    peek_back ¶
    Source

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

    peek_front ¶
    Source

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

    pop_back ¶
    Source

    pop_back :: proc(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(q: ^$Q/Queue($T)) -> (elem: $T, ok: bool) {…}
     

    Safely pop an element from the back of the queue

    pop_front ¶
    Source

    pop_front :: proc(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(q: ^$Q/Queue($T)) -> (elem: $T, ok: bool) {…}
     

    Safely pop an element from the front of the queue

    push_back ¶
    Source

    push_back :: proc(q: ^$Q/Queue($T), elem: $T) -> (ok: bool, err: runtime.Allocator_Error) {…}
     

    Push an element to the back of the queue

    push_back_elems ¶
    Source

    push_back_elems :: proc(q: ^$Q/Queue($T), .. elems: ..$T) -> (ok: bool, err: runtime.Allocator_Error) {…}
     

    Push multiple elements to the back of the queue

    push_front ¶
    Source

    push_front :: proc(q: ^$Q/Queue($T), elem: $T) -> (ok: bool, err: runtime.Allocator_Error) {…}
     

    Push an element to the front of the queue

    reserve ¶
    Source

    reserve :: proc(q: ^$Q/Queue($T), capacity: int) -> runtime.Allocator_Error {…}
     

    Reserve enough space for at least the specified capacity

    set ¶
    Source

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

    space ¶
    Source

    space :: proc(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-2025-05 (vendor "odin") Windows_amd64 @ 2025-05-08 21:12:59.641031300 +0000 UTC