std.deque

ring-buffer deque in an arena; O(1) push/pop at both ends; grows 2x

Deque

pub Deque :: struct($T: type) {
    region: *Arena,
    data: []T,
    head: usize,
    count: usize,
}

• region: where it grows (borrowed)
• data: the ring; capacity == data.len
• head: where the front element is

Deque.len

pub len :: fn(self: *Self) -> usize

Deque.is_empty

pub is_empty :: fn(self: *Self) -> bool

Deque.push_back

pub push_back :: fn(self: *Self, item: T)

Deque.push_front

pub push_front :: fn(self: *Self, item: T)

Deque.pop_front

pub pop_front :: fn(self: *Self) -> ?T

take the front; null if empty

Deque.pop_back

pub pop_back :: fn(self: *Self) -> ?T

take the back; null if empty

Deque.front

pub front :: fn(self: *Self) -> ?T

Deque.back

pub back :: fn(self: *Self) -> ?T

Deque.get

pub get :: fn(self: *Self, i: usize) -> T

element i from the front; i < len()

Deque.set

pub set :: fn(self: *Self, i: usize, v: T)

Deque.each

pub each :: fn(self: *Self) -> Each(T)

front to back, left in place

Deque.clear

pub clear :: fn(self: *Self)

Each

pub Each :: struct($T: type) {
    d: *Deque(T),
    i: usize,
}

iterator from Deque.each

Each.next

pub next :: fn(self: *Self) -> ?T

make

pub make :: fn($T: type, a: *Arena) -> Deque(T)

with_cap

pub with_cap :: fn($T: type, a: *Arena, cap: usize) -> Deque(T)

deque in a with room for cap before it grows