Struct PriorityResource 

pub struct PriorityResource { /* private fields */ }

A cloneable handle to a capacity-limited resource pool with priority scheduling.

Like Resource, units are acquired by calling request and awaiting the returned future. Unlike Resource, waiters are served in priority order: the waiter with the lowest priority number is served first. Within the same priority level, waiters are served FIFO.

Priority convention: lower number = higher priority (0 is highest).

PriorityResource wraps an Rc<RefCell<>> internally, so cloning is cheap and all clones share the same pool. It is !Send + !Sync — consistent with SimEnv.

An urgent case overtakes a routine one that queued first:

use std::cell::RefCell;
use std::rc::Rc;
use simu::{SimEnv, PriorityResource};

let mut env = SimEnv::with_seed(0);
let doctor = PriorityResource::new(1);
let seen = Rc::new(RefCell::new(Vec::new()));

// Occupy the doctor until t = 1.
let h = env.handle();
let d = doctor.clone();
env.spawn(async move {
    let _g = d.request(5).await;
    h.timeout(1.0).await;
});

// Two patients queue while the doctor is busy — routine (10) arrives
// before urgent (0), but urgent is served first.
for (name, priority) in [("routine", 10), ("urgent", 0)] {
    let d = doctor.clone();
    let seen = Rc::clone(&seen);
    env.spawn(async move {
        let _g = d.request(priority).await;
        seen.borrow_mut().push(name);
    });
}

env.run();
assert_eq!(*seen.borrow(), ["urgent", "routine"]); // lower number wins

Internally this is a WaitQueue<u32> (a pub(crate) helper): the u32 priority is the ordering key, and the queue’s internal sequence counter provides FIFO tie-breaking within a level.

Implementations

impl PriorityResource

pub fn new(capacity: usize) -> Self

Create a new priority resource pool with the given capacity.

Panics

Panics if capacity is zero.

pub fn request(&self, priority: u32) -> PriorityResourceRequest

Request one unit at the given priority (lower = higher priority).

Resolves immediately if a unit is available; otherwise suspends the calling process and wakes it before any lower-priority waiter when a unit becomes free.

The returned PriorityResourceGuard releases the unit when dropped.

pub fn in_use(&self) -> usize

Number of units currently in use.

pub fn capacity(&self) -> usize

Total capacity of this resource pool.

pub fn queue_len(&self) -> usize

Number of processes currently queued waiting for a unit, across all priority levels. Excludes abandoned (canceled) requests.

Trait Implementations

impl Clone for PriorityResource

fn clone(&self) -> PriorityResource

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PriorityResource

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.