Struct PacketQueue 

struct PacketQueue<K, T> {
    state: SyncMutex<PacketQueueState<K, T>>,
    limits: PacketAdmissionLimits,
    work_available: Condvar,
    idle: Notify,
    progress: Notify,
}

Bounded ordered multi-producer lanes with a finite snapshot drain at each tick boundary.

Fields

state: SyncMutex<PacketQueueState<K, T>>

limits: PacketAdmissionLimits

work_available: Condvar

idle: Notify

progress: Notify

Implementations

impl<K, T> PacketQueue<K, T>

where K: Copy + Eq + Hash + Ord,

fn new() -> Self

fn with_limits(limits: PacketAdmissionLimits) -> Self

fn try_submit( &self, key: K, execution: ScheduledPacketExecution, admission_bytes: usize, value: T, ) -> Result<(), PacketAdmissionError>

fn open(&self)

async fn drain_for_tick(&self)

fn finish_tick_drain(&self, before_sequence: u64)

fn begin_tick_drain(&self) -> Option<(u64, bool)>

fn tick_drain_complete(&self, before_sequence: u64) -> bool

async fn wait_for_progress_since(&self, completed: u64)

fn progress_baseline(&self) -> Option<u64>

fn has_progress_since(&self, completed: u64) -> bool

fn has_work(state: &PacketQueueState<K, T>) -> bool

fn discard_lane(&self, key: K)

fn stop(&self)

fn next(&self) -> Option<PacketWork<'_, K, T>>

fn start_next( state: &mut PacketQueueState<K, T>, before_sequence: Option<u64>, ) -> Option<(K, ScheduledPacketExecution, usize, T)>

fn select_next( state: &PacketQueueState<K, T>, before_sequence: Option<u64>, ) -> Option<(u64, K, ScheduledPacketExecution)>

fn finish_one( &self, key: K, execution: ScheduledPacketExecution, admission_bytes: usize, )

fn mark_ready( state: &mut PacketQueueState<K, T>, sequence: u64, key: K, execution: ScheduledPacketExecution, )

fn next_ready_sequence(state: &PacketQueueState<K, T>) -> Option<u64>