Struct promising_future::FutureStreamWaiter

pub struct FutureStreamWaiter<'a, T: Send + 'a> { /* fields omitted */ }

Waiter for Futures in a FutureStream.

A singleton waiter for Futures, associated with a specific FutureStream. This may be used in a multithreaded environment to wait for Futures to resolve while other threads fulfill Promises and add new Futures to the FutureStream.

let fs = FutureStream::new();
fs.add(future);
// ...
let mut waiter = fs.waiter();
while let Some(future) = waiter.wait() {
    match future.value() {
      None => (),         // Future unfulfilled
      Some(val) => val,
    }
}

It may also be converted into an Iterator over the values yielded by resolved Futures (unfulfilled Promises are ignored).

let fs = FutureStream::new();
fs.add(fut1);
for val in fs.waiter() {
   // ...
}

Methods

impl<'fs, T: Send> FutureStreamWaiter<'fs, T>

fn wait(&mut self) -> Option<Future<T>>

Return resolved Futures. Blocks if there are outstanding Futures which are not yet resolved. Returns None when there are no more outstanding Futures.

fn poll(&mut self) -> Option<Future<T>>

Return next resolved Future, but don't wait for more to resolve.

Trait Implementations

impl<'fs, T: Send> Drop for FutureStreamWaiter<'fs, T>

fn drop(&mut self)

A method called when the value goes out of scope.

impl<'fs, T: Send + 'fs> IntoIterator for FutureStreamWaiter<'fs, T>

type Item = T

The type of the elements being iterated over.

type IntoIter = FutureStreamIter<'fs, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.