Struct Pending 

pub struct Pending<K, T> {
    answerer: Sender<(K, T)>,
    answers: Receiver<(K, T)>,
    state: SnapshotReader<WorldState>,
    timeout: Option<f32>,
    outstanding: Vec<(K, Option<f32>)>,
}

The requests one world owes a caller, and the answers that have come back.

One Pending serves one world: it is built with the state that world publishes, and every request made through it goes to it. A caller that asks two worlds for two things keeps two.

K is what the caller names a request by, and T what the world answers with.

Fields

answerer: Sender<(K, T)>

What a job publishes its answer through. Cloned into every request.

answers: Receiver<(K, T)>

Where the answers land, in the order they were published.

state: SnapshotReader<WorldState>

The state of the world that owes the answers.

timeout: Option<f32>

How many seconds a request may go unanswered; None waits for as long as the world owes it.

outstanding: Vec<(K, Option<f32>)>

The requests still outstanding, and how many seconds each has left.

Implementations

impl<K, T> Pending<K, T>

where K: Eq + Clone + Send + 'static, T: Send + 'static,

pub fn new(state: SnapshotReader<WorldState>, timeout: Option<f32>) -> Self

Requests for the world state reports on, each allowed to go unanswered for timeout seconds. None waits until the world answers or ends.

pub fn request<F>( &mut self, sender: &JobSender, key: K, make: F, ) -> Result<(), SendError>

where F: FnOnce(&mut World) -> T + Send + 'static,

Ask the world behind sender for what make returns, as the request key names.

make runs once, on the world’s own thread, and whatever it returns is the answer key receives. The send is refused when that world’s queue is full or it has stopped, and then no request is outstanding: the caller decides whether to ask again on a later tick.

A request already outstanding under key is sent again without lengthening its wait: the answer already owed is the one that arrives, and the tick the first was asked on is the one the wait is measured from.

pub fn advance( &mut self, delta_seconds: f32, settled: &mut Vec<(K, Settled<T>)>, )

What ended on this tick: the requests the world answered, and the ones given up on, each under the key it was asked with.

Call it once per tick of the asking world, and take every item it writes: an unanswered request is given up on only once, and an answer is handed out only once. A request is expired when the time it was given runs out, or at once when the world that owed it ended — a job that panicked takes its answer with it, and a world that stopped never runs another.

An answer that arrived for a request no longer outstanding is dropped: the request was given up on, and whatever it asked for has already been dealt with. Requests come out oldest first — the answered in the order the world published them, then the expired in the order they were asked — so two runs of the same durations settle the same requests in the same order.

settled is cleared and reused, so a caller that keeps one allocates nothing per tick but what the answers themselves weigh.

fn take_outstanding(&mut self, key: &K) -> bool

Whether a request named key is still owed, taking it out if it is.