Struct FixedHeapChannelTable 

pub struct FixedHeapChannelTable<const SLOTS: usize, const REORDER_CAP: usize, const MAX_PAYLOAD: usize, const POOL: usize, A = Global>
where
    A: Allocator,
{ /* private fields */ }

Trait Implementations

impl<const SLOTS: usize, const REORDER_CAP: usize, const MAX_PAYLOAD: usize, const POOL: usize, A> ChannelTable for FixedHeapChannelTable<SLOTS, REORDER_CAP, MAX_PAYLOAD, POOL, A>

where A: Allocator,

fn capacity(&self) -> usize

fn len(&self) -> usize

fn index_of(&self, link: &LinkId) -> Option<usize>

fn link_at(&self, index: usize) -> LinkId

fn ensure(&mut self, link: &LinkId) -> Result<usize, EnsureChannelError>

fn close(&mut self, link: &LinkId)

fn next_expected(&self, index: usize) -> ChannelSequence

fn set_next_expected(&mut self, index: usize, sequence: ChannelSequence)

fn buffered_sequences(&self, index: usize) -> &[ChannelSequence]

fn buffered_message_type(&self, index: usize, sub: usize) -> MessageType

fn buffered_payload(&self, index: usize, sub: usize) -> &[u8]

fn push_buffered( &mut self, index: usize, sequence: ChannelSequence, message_type: MessageType, payload: &[u8], ) -> BufferOutcome

fn swap_remove_buffered(&mut self, index: usize, sub: usize)

fn next_tx_sequence(&self, index: usize) -> ChannelSequence

fn set_next_tx_sequence(&mut self, index: usize, sequence: ChannelSequence)

fn window(&self, index: usize) -> ChannelWindow

fn set_window(&mut self, index: usize, window: ChannelWindow)

fn outstanding_count(&self, index: usize) -> usize

fn outstanding_packet_hashes(&self, index: usize) -> &[PacketHash]

fn outstanding_command_id(&self, index: usize, sub: usize) -> CommandId

fn outstanding_sent_at(&self, index: usize, sub: usize) -> InstantMillis

fn outstanding_timeout_at(&self, index: usize, sub: usize) -> InstantMillis

fn set_outstanding_timeout_at( &mut self, index: usize, sub: usize, timeout_at: InstantMillis, )

fn outstanding_tries(&self, index: usize, sub: usize) -> u8

fn set_outstanding_tries(&mut self, index: usize, sub: usize, tries: u8)

fn outstanding_sequence(&self, index: usize, sub: usize) -> ChannelSequence

fn outstanding_message_type(&self, index: usize, sub: usize) -> MessageType

fn outstanding_body(&self, index: usize, sub: usize) -> &[u8]

fn outstanding_iv(&self, index: usize, sub: usize) -> [u8; 16]

fn push_outstanding( &mut self, index: usize, send: OutstandingSend<'_>, ) -> TxOutcome

fn retire_outstanding(&mut self, index: usize, sub: usize)

fn channel_earliest_tx_timeout(&self, index: usize) -> Option<InstantMillis>

The channel’s cached earliest outstanding deadline: a due-scan skips any channel whose value sits in the future.

fn set_channel_earliest_tx_timeout( &mut self, index: usize, earliest: Option<InstantMillis>, )

fn is_empty(&self) -> bool

fn rescan_channel_earliest_tx_timeout(&mut self, index: usize)

fn absorb_outstanding_timeout_change( &mut self, index: usize, change: OutstandingTimeoutChange, )

Folds one deadline mutation into the channel’s cached earliest: a push or a lowered deadline settles in place, while raising or retiring the current holder re-walks that one ring. Every mutator routes through here, so the cache never desyncs and never costs a cross-channel scan.

fn scan_earliest_tx_timeout(&self) -> Option<InstantMillis>

The debug oracle for the cached earliests: the full channels × ring walk.

fn earliest_tx_timeout_at(&self) -> Option<InstantMillis>

fn first_due_channel(&self, now: InstantMillis) -> Option<usize>

impl<const SLOTS: usize, const REORDER_CAP: usize, const MAX_PAYLOAD: usize, const POOL: usize, A> Default for FixedHeapChannelTable<SLOTS, REORDER_CAP, MAX_PAYLOAD, POOL, A>

where A: Allocator + Default,

fn default() -> FixedHeapChannelTable<SLOTS, REORDER_CAP, MAX_PAYLOAD, POOL, A>

Returns the “default value” for a type.