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 is dropped when the key is pruned. While the key stays tracked, the resolver can read, update, or take it.

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. A verdict accepted before cancellation closes its receiver is returned as a canceled 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 later retained subscribers can be redelivered the same bytes with redeliver once the consumer accepts it or drops its verdict. 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 an earlier validation was still pending. The cached response is either accepted or still unjudged because the consumer dropped the earlier verdict. Panics if the key is not tracked or no response is cached.

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 when a response is invalid or does not satisfy every delivered subscriber and the resolver wants to retry the key.

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 cancellation closes the receiver without an accepted verdict. Otherwise, canceled deliveries return their verdict for source accounting without affecting any current fetch for the key. Active deliveries clear their slot so the key can be retried or redelivered. A verdict sender dropped by the consumer completes with no outcome.

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.