Struct Tracker 

pub struct Tracker<Con, Context = (), State = ()>
where
    Con: Consumer,
    Con::Value: Clone + Send + 'static,
    Context: Clone + Send + 'static,
{ /* private fields */ }

Tracks in-flight consumer deliveries keyed by resolver key.

Context carries resolver-specific metadata back to the caller when validation completes.

State holds per-key resolver state that should be dropped when the key is pruned, or explicitly taken when the resolver completes the fetch.

Implementations

impl<Con, Context, State> Tracker<Con, Context, State>

where Con: Consumer, Con::Value: Clone + Send + 'static, Context: Clone + Send + 'static,

pub fn new(consumer: Con) -> Self

Create an empty tracker backed by the provided consumer.

pub fn contains(&self, key: &Con::Key) -> bool

Returns true when the key has an active tracked fetch.

pub fn remove(&mut self, key: &Con::Key) -> bool

Remove a key and abort any in-progress delivery for it.

Returns true if the key was present. Any completion produced by an aborted delivery is discarded by next_completion.

pub fn retain<F: FnMut(&Con::Key) -> bool>(&mut self, predicate: F) -> usize

Retain only entries for which the predicate returns true.

Dropped entries abort in-progress deliveries. Returns the number of removed entries.

pub fn drain(&mut self) -> usize

Remove all entries and abort all in-progress deliveries.

Returns the number of entries removed.

pub fn deliver( &mut self, delivery: Delivery<Con::Key, Con::Subscriber>, context: Context, value: Con::Value, )

Deliver a newly received response to the consumer.

The response is cached so that, after the consumer accepts it, later retained subscribers can be redelivered the same bytes with redeliver. Panics if the key is not tracked.

pub fn redeliver(&mut self, delivery: Delivery<Con::Key, Con::Subscriber>)

Deliver the cached response to another set of subscribers.

This is intended for subscribers added while the first validation was still pending. Panics if the key is not tracked, no response is cached, or the cached response has not yet been accepted.

pub fn response_accepted(&self, key: &Con::Key) -> bool

Returns true if the cached response for this key has been accepted.

pub fn accept_response(&mut self, key: &Con::Key)

Mark the cached response accepted by the consumer.

Panics if the key is not tracked or no response is cached.

pub fn discard_response(&mut self, key: &Con::Key)

Drop the cached response without removing the tracked key.

Use this after a consumer rejects a response and the resolver wants to retry the same key with different bytes or metadata.

pub async fn next_completion( &mut self, ) -> Result<Completion<Con::Key, Con::Subscriber, Context>, Aborted>

Wait for the next consumer validation result.

Returns Aborted when the delivery was canceled before completion. Successful completions clear the active delivery slot for that key so it can be retried or redelivered. Completions for an older same-key delivery are treated as aborted.

impl<Con, Context> Tracker<Con, Context>

where Con: Consumer, Con::Value: Clone + Send + 'static, Context: Clone + Send + 'static,

pub fn insert(&mut self, key: Con::Key) -> bool

Start tracking a key without any resolver-specific state.

Returns true when the key was inserted. If the key is already tracked, this leaves the existing entry untouched and returns false.