Struct futures::stream::select_all::SelectAll

pub struct SelectAll<St> { /* private fields */ }

An unbounded set of streams

This “combinator” provides the ability to maintain a set of streams and drive them all to completion.

Streams are pushed into this set and their realized values are yielded as they become ready. Streams will only be polled when they generate notifications. This allows to coordinate a large number of streams.

Note that you can create a ready-made SelectAll via the select_all function in the stream module, or you can start with an empty set with the SelectAll::new constructor.

Implementations

impl<St> SelectAll<St>where St: Stream + Unpin,

pub fn new() -> SelectAll<St>

Constructs a new, empty SelectAll

The returned SelectAll does not contain any streams and, in this state, SelectAll::poll will return Poll::Ready(None).

pub fn len(&self) -> usize

Returns the number of streams contained in the set.

This represents the total number of in-flight streams.

pub fn is_empty(&self) -> bool

Returns true if the set contains no streams

pub fn push(&mut self, stream: St)

Push a stream into the set.

This function submits the given stream to the set for managing. This function will not call poll on the submitted stream. The caller must ensure that SelectAll::poll is called in order to receive task notifications.

pub fn iter(&self) -> Iter<'_, St>

Returns an iterator that allows inspecting each stream in the set.

pub fn iter_mut(&mut self) -> IterMut<'_, St>

Returns an iterator that allows modifying each stream in the set.

pub fn clear(&mut self)

Clears the set, removing all streams.

Trait Implementations

impl<St> Debug for SelectAll<St>where St: Debug,

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

Formats the value using the given formatter.

impl<St> Default for SelectAll<St>where St: Stream + Unpin,

fn default() -> SelectAll<St>

Returns the “default value” for a type.

impl<St> Extend<St> for SelectAll<St>where St: Stream + Unpin,

fn extend<T>(&mut self, iter: T)where T: IntoIterator<Item = St>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<St> FromIterator<St> for SelectAll<St>where St: Stream + Unpin,

fn from_iter<T>(iter: T) -> SelectAll<St>where T: IntoIterator<Item = St>,

Creates a value from an iterator.

impl<St> FusedStream for SelectAll<St>where St: Stream + Unpin,

fn is_terminated(&self) -> bool

Returns true if the stream should no longer be polled.

impl<'a, St> IntoIterator for &'a SelectAll<St>where St: Stream + Unpin,

type Item = &'a St

The type of the elements being iterated over.

type IntoIter = Iter<'a, St>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a SelectAll<St> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, St> IntoIterator for &'a mut SelectAll<St>where St: Stream + Unpin,

type Item = &'a mut St

The type of the elements being iterated over.

type IntoIter = IterMut<'a, St>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut SelectAll<St> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<St> IntoIterator for SelectAll<St>where St: Stream + Unpin,

type Item = St

The type of the elements being iterated over.

type IntoIter = IntoIter<St>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <SelectAll<St> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<St> Stream for SelectAll<St>where St: Stream + Unpin,

type Item = <St as Stream>::Item

Values yielded by the stream.

fn poll_next( self: Pin<&mut SelectAll<St>>, cx: &mut Context<'_> ) -> Poll<Option<<SelectAll<St> as Stream>::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, St> Unpin for SelectAll<St>where __Origin<'__pin, St>: Unpin,