Struct PeerMessagePrioritizer 

pub struct PeerMessagePrioritizer {
    pub queues: HashMap<String, Vec<PrioritizedMessage>>,
    pub config: AgingConfig,
    pub stats: PrioritizerStats,
    pub current_tick: u64,
    pub next_id: u64,
}

Multi-level outbound message prioritizer with per-peer queues and aging.

Ordering guarantee

Within a peer’s queue messages are sorted so that:

1. Higher effective_priority comes first.
2. Among messages with the same effective_priority, the one enqueued earliest (lowest enqueued_tick) comes first (FIFO).

Fields

queues: HashMap<String, Vec<PrioritizedMessage>>

Per-peer queues; each Vec is kept sorted (front = highest priority).

config: AgingConfig

Aging and capacity configuration.

stats: PrioritizerStats

Running statistics.

current_tick: u64

Logical clock advanced via advance_tick.

next_id: u64

Counter used to assign unique message identifiers.

Implementations

impl PeerMessagePrioritizer

pub fn new(config: AgingConfig) -> Self

Create a new prioritizer with the supplied configuration.

pub fn enqueue( &mut self, peer_id: String, priority: MessagePriority, payload_bytes: u64, ) -> Option<u64>

Enqueue a new message for peer_id.

If the peer’s queue is already at max_queue_size:

1. Attempt to drop the lowest-priority message (Background first, then Normal).
2. If the queue is still full after the drop attempt, return None.

On success, returns Some(msg_id).

pub fn dequeue(&mut self, peer_id: &str) -> Option<PrioritizedMessage>

Remove and return the highest-priority message for peer_id, or None if the peer has no queued messages.

pub fn advance_tick(&mut self)

Advance the logical clock by one tick and apply aging promotions.

Any message whose waiting time (current_tick - enqueued_tick) meets or exceeds promote_after_ticks and whose effective_priority is below Urgent is promoted by one level. Queues that had at least one promotion are re-sorted to preserve the ordering invariant.

pub fn stats(&self) -> &PrioritizerStats

Return a reference to the accumulated statistics.

pub fn queue_depth(&self, peer_id: &str) -> usize

Return the number of messages currently queued for peer_id.