Struct ExitQueue 

pub struct ExitQueue<K: Eq, T> { /* private fields */ }

A keyed collection that keeps removed entries available for exit animations.

Call ExitQueue::sync with the current live (key, value) pairs after each state update. Entries absent from the live set remain in the collection with visible == false until ExitQueue::finish removes them. If a key is added again before its exit completes, the existing entry is updated and resurrected instead of being inserted a second time.

Implementations

impl<K: Eq, T> ExitQueue<K, T>

pub fn new() -> Self

Create an empty keyed exit queue with no timeout.

Entries are then retained until ExitQueue::finish is called for them. Prefer ExitQueue::with_exit_timeout unless the host is guaranteed to stay rendered for the whole exit, since an animation that never runs never completes.

pub fn with_exit_timeout(timeout: Duration) -> Self

Create a queue that stops retaining an entry timeout after it began exiting.

The timeout is a backstop, not the animation duration: ExitQueue::finish still removes entries as soon as their animation reports completion. Set it slightly longer than the exit animation so a slow frame cannot cut one short. Without it, a collection that stops being rendered mid-exit (a hidden tab, an inactive workspace) retains those entries indefinitely.

pub fn expire(&mut self) -> usize

Drop entries whose exit timeout has elapsed, returning how many were released.

ExitQueue::sync calls this, so it is only needed when a queue can go many frames without syncing and you still want its memory released.

pub fn transfer_out(&mut self, key: &K) -> Option<ExitTransfer<K, T>>

Remove an entry so another queue can adopt it, preserving its exit progress.

Use when an item migrates between collections while leaving, for example a row that moves to another group as it is being deleted. Re-inserting it with ExitQueue::sync on the target would restart its exit; ExitQueue::adopt preserves the original deadline.

pub fn adopt(&mut self, transfer: ExitTransfer<K, T>)

Adopt an entry handed over by ExitQueue::transfer_out.

An existing entry under the same key is replaced. The adopted deadline is kept, so an item cannot extend its own retention by hopping between collections.

pub fn sync<I>(&mut self, live: I)

where K: Clone, I: IntoIterator<Item = (K, T)>,

Synchronize the queue with the current live (key, value) pairs.

Existing keys are updated in place. Keys not present in live become exiting, while new keys are inserted as visible. Duplicate keys in one input are updated rather than doubled.

pub fn iter(&self) -> impl Iterator<Item = (&K, &T, bool)> + '_

Iterate over (key, value, visible) entries in insertion order.

visible is true for current live entries and false for entries retained only for an exit animation.

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

Finish an entry’s exit animation and remove it from the queue.

Returns true when an exiting entry was removed. Calling this for a live entry or an unknown key is a no-op and returns false.

pub fn is_exiting(&self, key: &K) -> bool

Return whether a key currently exists only for its exit animation.

pub fn len(&self) -> usize

Return the number of live and exiting entries.

pub fn is_empty(&self) -> bool

Return whether the collection has no live or exiting entries.

Trait Implementations

impl<K: Default + Eq, T: Default> Default for ExitQueue<K, T>

fn default() -> ExitQueue<K, T>

Returns the “default value” for a type.