Struct FrontierScratch 

pub struct FrontierScratch { /* private fields */ }

Reusable double-buffer for BFS / multi-hop frontier expansion.

Reduces per-level Vec allocation churn: instead of allocating fresh Vec<u64> buffers for current and next at every hop, a single FrontierScratch is allocated once and reused across all hops in a query.

Semantics

FrontierScratch has no visited-set semantics. It does not deduplicate frontier entries. Callers that require reachability dedup must implement that separately. This is intentional — see spec §4.5.

Usage

let mut frontier = FrontierScratch::new(256);
// populate initial frontier:
frontier.current_mut().extend(src_slots);

// expand hop:
for &slot in frontier.current() {
    frontier.next_mut().extend(neighbors(slot));
}
frontier.advance(); // swap: next → current, clear next

// read expanded frontier:
for &slot in frontier.current() { ... }

Implementations

impl FrontierScratch

pub fn new(capacity: usize) -> Self

Allocate a FrontierScratch pre-reserving capacity slots in each buffer.

pub fn advance(&mut self)

Swap current ↔ next and clear next.

Call this after populating next_mut() to advance to the next BFS level.

pub fn current(&self) -> &[u64]

Read-only view of the current frontier.

pub fn current_mut(&mut self) -> &mut Vec<u64>

Mutable reference to the current frontier (for initial population).

pub fn next_mut(&mut self) -> &mut Vec<u64>

Mutable reference to the next frontier (populated during expansion).

pub fn clear(&mut self)

Clear both buffers (reset for reuse in a new query).

pub fn bytes_allocated(&self) -> usize

Byte footprint of live data in both buffers (for memory-limit checks).

Uses len() rather than capacity() so that pre-allocated but unused capacity does not trigger the memory limit before any edges are traversed.