Struct KeyedFuturesUnordered 

pub struct KeyedFuturesUnordered<K, F>
where
    F: Future,
{
    notification_receiver: UnboundedReceiver<K>,
    notification_sender: UnboundedSender<K>,
    futures: HashMap<K, F>,
}

Efficiently manages a dynamic set of futures as per [futures::stream::FuturesUnordered]. Unlike FuturesUnordered, each future has an associated key. This key is returned along with the future’s output, and can be used to cancel and remove a future from the set.

Implements [futures::Stream], producing a stream of completed futures and their associated keys.

Stream behavior

Stream::poll_next returns:

• Poll::Ready(None) if there are no futures managed by this object.
• Poll::Ready(Some((key, output))) with the key and output of a ready future when there is one.
• Poll::Pending when there are futures managed by this object, but none are currently ready.

Unlike for a generic Stream, it is permitted to call poll_next again after having received Poll::Ready(None). It will still behave as above (i.e. returning Pending or Ready if futures have since been inserted).

Fields

notification_receiver: UnboundedReceiver<K>

Receiver on which we’re notified of keys that are ready to be polled.

notification_sender: UnboundedSender<K>

Sender on which to notify notifications_receiver that keys are ready to be polled.

futures: HashMap<K, F>

Map of pending futures.

Implementations

impl<K, F> KeyedFuturesUnordered<K, F>

where F: Future,

pub(crate) fn project<'pin>( self: Pin<&'pin mut Self>, ) -> __KeyedFuturesUnorderedProjection<'pin, K, F>

pub(crate) fn project_ref<'pin>( self: Pin<&'pin Self>, ) -> __KeyedFuturesUnorderedProjectionRef<'pin, K, F>

impl<K, F> KeyedFuturesUnordered<K, F>

where F: Future, K: Eq + Hash + Clone,

pub fn new() -> Self

Create an empty KeyedFuturesUnordered.

pub fn try_insert( &mut self, key: K, fut: F, ) -> Result<(), KeyAlreadyInsertedError<K, F>>

Insert a future and associate it with key. Return an error if there is already an entry for key.

pub fn remove(&mut self, key: &K) -> Option<(K, F)>

Remove the entry for key, if any, and return the corresponding future.

pub fn get<'a>(&'a self, key: &K) -> Option<&'a F>

Get the future corresponding to key, if any.

As for Self::get_mut, removing or replacing its std::task::Waker without waking it (e.g. using internal mutability) results in unspecified (but sound) behavior.

pub fn get_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut F>

Get the future corresponding to key, if any.

The future should not be polld, nor its registered std::task::Waker otherwise removed or replaced (unless it is also woken; see below). The result of doing either is unspecified (but sound).

This method is useful primarily when the future has other functionality or data bundled with it besides its implementation of the Future trait, though it is permitted to mutate the object in a way that causes it to become ready (i.e. wakes and discards its registered std::task::Waker), or become unready (cause its next poll result to be Poll::Pendingwhen it otherwise would have beenPoll::Readyand may have already woken its registeredWaker`).

Trait Implementations

impl<K: Debug, F> Debug for KeyedFuturesUnordered<K, F>

where F: Future + Debug,

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

Formats the value using the given formatter.

impl<K, F> Stream for KeyedFuturesUnordered<K, F>

where F: Future + Unpin, K: Clone + Hash + Eq + Send + Sync + 'static,

type Item = (K, <F as Future>::Output)

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'pin, K, F> Unpin for KeyedFuturesUnordered<K, F>

where F: Future, PinnedFieldsOf<__KeyedFuturesUnordered<'pin, K, F>>: Unpin,