Struct futures01::stream::futures_unordered::FuturesUnordered [−][src]
An unbounded set of futures.
This “combinator” also serves a special function in this library, providing the ability to maintain a set of futures that and manage driving them all to completion.
Futures are pushed into this set and their realized values are yielded as
they are ready. This structure is optimized to manage a large number of
futures. Futures managed by FuturesUnordered
will only be polled when they
generate notifications. This reduces the required amount of work needed to
coordinate large numbers of futures.
When a FuturesUnordered
is first created, it does not contain any futures.
Calling poll
in this state will result in Ok(Async::Ready(None))
to be
returned. Futures are submitted to the set using push
; however, the
future will not be polled at this point. FuturesUnordered
will only
poll managed futures when FuturesUnordered::poll
is called. As such, it
is important to call poll
after pushing new futures.
If FuturesUnordered::poll
returns Ok(Async::Ready(None))
this means that
the set is currently not managing any futures. A future may be submitted
to the set at a later time. At that point, a call to
FuturesUnordered::poll
will either return the future’s resolved value
or Ok(Async::NotReady)
if the future has not yet completed.
Note that you can create a ready-made FuturesUnordered
via the
futures_unordered
function in the stream
module, or you can start with an
empty set with the FuturesUnordered::new
constructor.
Implementations
impl<T> FuturesUnordered<T> where
T: Future,
[src]
T: Future,
pub fn new() -> FuturesUnordered<T>
[src]
Constructs a new, empty FuturesUnordered
The returned FuturesUnordered
does not contain any futures and, in this
state, FuturesUnordered::poll
will return Ok(Async::Ready(None))
.
impl<T> FuturesUnordered<T>
[src]
pub fn len(&self) -> usize
[src]
Returns the number of futures contained in the set.
This represents the total number of in-flight futures.
pub fn is_empty(&self) -> bool
[src]
Returns true
if the set contains no futures
pub fn push(&mut self, future: T)
[src]
Push a future into the set.
This function submits the given future to the set for managing. This
function will not call poll
on the submitted future. The caller must
ensure that FuturesUnordered::poll
is called in order to receive task
notifications.
pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘ
[src]
Returns an iterator that allows modifying each future in the set.
Trait Implementations
impl<T> Debug for FuturesUnordered<T> where
T: Debug,
[src]
T: Debug,
impl<T> Default for FuturesUnordered<T> where
T: Future,
[src]
T: Future,
pub fn default() -> FuturesUnordered<T>
[src]
impl<T> Drop for FuturesUnordered<T>
[src]
impl<F> FromIterator<F> for FuturesUnordered<F> where
F: Future,
[src]
F: Future,
pub fn from_iter<T>(iter: T) -> FuturesUnordered<F> where
T: IntoIterator<Item = F>,
[src]
T: IntoIterator<Item = F>,
impl<T> Send for FuturesUnordered<T> where
T: Send,
[src]
T: Send,
impl<T> Stream for FuturesUnordered<T> where
T: Future,
[src]
T: Future,
type Item = <T as Future>::Item
The type of item this stream will yield on success.
type Error = <T as Future>::Error
The type of error this stream may generate.
pub fn poll(
&mut self
) -> Result<Async<Option<<T as Future>::Item>>, <T as Future>::Error>
[src]
&mut self
) -> Result<Async<Option<<T as Future>::Item>>, <T as Future>::Error>
pub fn wait(self) -> Wait<Self>ⓘ
[src]
pub fn into_future(self) -> StreamFuture<Self>
[src]
pub fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> U,
[src]
F: FnMut(Self::Item) -> U,
pub fn map_err<U, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> U,
[src]
F: FnMut(Self::Error) -> U,
pub fn filter<F>(self, f: F) -> Filter<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn filter_map<F, B>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
[src]
F: FnMut(Self::Item) -> Option<B>,
pub fn then<F, U>(self, f: F) -> Then<Self, F, U> where
F: FnMut(Result<Self::Item, Self::Error>) -> U,
U: IntoFuture,
[src]
F: FnMut(Result<Self::Item, Self::Error>) -> U,
U: IntoFuture,
pub fn and_then<F, U>(self, f: F) -> AndThen<Self, F, U> where
F: FnMut(Self::Item) -> U,
U: IntoFuture<Error = Self::Error>,
[src]
F: FnMut(Self::Item) -> U,
U: IntoFuture<Error = Self::Error>,
pub fn or_else<F, U>(self, f: F) -> OrElse<Self, F, U> where
F: FnMut(Self::Error) -> U,
U: IntoFuture<Item = Self::Item>,
[src]
F: FnMut(Self::Error) -> U,
U: IntoFuture<Item = Self::Item>,
pub fn collect(self) -> Collect<Self>
[src]
pub fn concat2(self) -> Concat2<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
pub fn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
pub fn fold<F, T, Fut>(self, init: T, f: F) -> Fold<Self, F, Fut, T> where
F: FnMut(T, Self::Item) -> Fut,
Fut: IntoFuture<Item = T>,
Self::Error: From<<Fut as IntoFuture>::Error>,
[src]
F: FnMut(T, Self::Item) -> Fut,
Fut: IntoFuture<Item = T>,
Self::Error: From<<Fut as IntoFuture>::Error>,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
<Self::Item as Stream>::Error: From<Self::Error>,
[src]
Self::Item: Stream,
<Self::Item as Stream>::Error: From<Self::Error>,
pub fn skip_while<P, R>(self, pred: P) -> SkipWhile<Self, P, R> where
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
[src]
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
pub fn take_while<P, R>(self, pred: P) -> TakeWhile<Self, P, R> where
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
[src]
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
pub fn for_each<F, U>(self, f: F) -> ForEach<Self, F, U> where
F: FnMut(Self::Item) -> U,
U: IntoFuture<Item = (), Error = Self::Error>,
[src]
F: FnMut(Self::Item) -> U,
U: IntoFuture<Item = (), Error = Self::Error>,
pub fn from_err<E>(self) -> FromErr<Self, E> where
E: From<Self::Error>,
[src]
E: From<Self::Error>,
pub fn take(self, amt: u64) -> Take<Self>
[src]
pub fn skip(self, amt: u64) -> Skip<Self>
[src]
pub fn fuse(self) -> Fuse<Self>
[src]
pub fn by_ref(&mut self) -> &mut Self
[src]
pub fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
[src]
Self: UnwindSafe,
pub fn buffered(self, amt: usize) -> Buffered<Self> where
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
[src]
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
pub fn buffer_unordered(self, amt: usize) -> BufferUnordered<Self> where
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
[src]
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
pub fn merge<S>(self, other: S) -> Merge<Self, S> where
S: Stream<Error = Self::Error>,
[src]
S: Stream<Error = Self::Error>,
pub fn zip<S>(self, other: S) -> Zip<Self, S> where
S: Stream<Error = Self::Error>,
[src]
S: Stream<Error = Self::Error>,
pub fn chain<S>(self, other: S) -> Chain<Self, S> where
S: Stream<Item = Self::Item, Error = Self::Error>,
[src]
S: Stream<Item = Self::Item, Error = Self::Error>,
pub fn peekable(self) -> Peekable<Self>
[src]
pub fn chunks(self, capacity: usize) -> Chunks<Self>
[src]
pub fn select<S>(self, other: S) -> Select<Self, S> where
S: Stream<Item = Self::Item, Error = Self::Error>,
[src]
S: Stream<Item = Self::Item, Error = Self::Error>,
pub fn forward<S>(self, sink: S) -> Forward<Self, S> where
S: Sink<SinkItem = Self::Item>,
Self::Error: From<<S as Sink>::SinkError>,
[src]
S: Sink<SinkItem = Self::Item>,
Self::Error: From<<S as Sink>::SinkError>,
pub fn split(self) -> (SplitSink<Self>, SplitStream<Self>) where
Self: Sink,
[src]
Self: Sink,
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
pub fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
[src]
F: FnMut(&Self::Error),
impl<T> Sync for FuturesUnordered<T> where
T: Sync,
[src]
T: Sync,
Auto Trait Implementations
impl<F> !RefUnwindSafe for FuturesUnordered<F>
impl<F> Unpin for FuturesUnordered<F>
impl<F> !UnwindSafe for FuturesUnordered<F>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,