[][src]Struct futures::stream::StreamFuture

#[must_use = "futures do nothing unless polled"]
pub struct StreamFuture<St> { /* fields omitted */ }

Future for the into_future method.

Methods

impl<St> StreamFuture<St> where
    St: Unpin + Stream
[src]

pub fn get_ref(&self) -> Option<&St>[src]

Acquires a reference to the underlying stream that this combinator is pulling from.

This method returns an Option to account for the fact that StreamFuture's implementation of Future::poll consumes the underlying stream during polling in order to return it to the caller of Future::poll if the stream yielded an element.

pub fn get_mut(&mut self) -> Option<&mut St>[src]

Acquires a mutable reference to the underlying stream that this combinator is pulling from.

Note that care must be taken to avoid tampering with the state of the stream which may otherwise confuse this combinator.

This method returns an Option to account for the fact that StreamFuture's implementation of Future::poll consumes the underlying stream during polling in order to return it to the caller of Future::poll if the stream yielded an element.

pub fn get_pin_mut(
    self: Pin<&'a mut StreamFuture<St>>
) -> Option<Pin<&'a mut St>>
[src]

Acquires a pinned mutable reference to the underlying stream that this combinator is pulling from.

Note that care must be taken to avoid tampering with the state of the stream which may otherwise confuse this combinator.

This method returns an Option to account for the fact that StreamFuture's implementation of Future::poll consumes the underlying stream during polling in order to return it to the caller of Future::poll if the stream yielded an element.

pub fn into_inner(self) -> Option<St>[src]

Consumes this combinator, returning the underlying stream.

Note that this may discard intermediate state of this combinator, so care should be taken to avoid losing resources when this is called.

This method returns an Option to account for the fact that StreamFuture's implementation of Future::poll consumes the underlying stream during polling in order to return it to the caller of Future::poll if the stream yielded an element.

Trait Implementations

impl<St> Future for StreamFuture<St> where
    St: Unpin + Stream
[src]

type Output = (Option<<St as Stream>::Item>, St)

The type of value produced on completion.

impl<St> Debug for StreamFuture<St> where
    St: Debug
[src]

impl<St> Unpin for StreamFuture<St> where
    St: Unpin + Stream
[src]

impl<St> FusedFuture for StreamFuture<St>[src]

Auto Trait Implementations

impl<St> Send for StreamFuture<St> where
    St: Send

impl<St> Sync for StreamFuture<St> where
    St: Sync

Blanket Implementations

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> FutureExt for T where
    T: Future + ?Sized
[src]

Important traits for Map<Fut, F>
fn map<U, F>(self, f: F) -> Map<Self, F> where
    F: FnOnce(Self::Output) -> U, 
[src]

Map this future's output to a different type, returning a new future of the resulting type. Read more

Important traits for Then<Fut1, Fut2, F>
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
    F: FnOnce(Self::Output) -> Fut,
    Fut: Future
[src]

Chain on a computation for when a future finished, passing the result of the future to the provided closure f. Read more

Important traits for Either<A, B>
fn left_future<B>(self) -> Either<Self, B> where
    B: Future<Output = Self::Output>, 
[src]

Wrap this future in an Either future, making it the left-hand variant of that Either. Read more

Important traits for Either<A, B>
fn right_future<A>(self) -> Either<A, Self> where
    A: Future<Output = Self::Output>, 
[src]

Wrap this future in an Either future, making it the right-hand variant of that Either. Read more

fn into_stream(self) -> IntoStream<Self>[src]

Convert this future into a single element stream. Read more

Important traits for Flatten<Fut>
fn flatten(self) -> Flatten<Self> where
    Self::Output: Future
[src]

Flatten the execution of this future when the successful result of this future is itself another future. Read more

fn flatten_stream(self) -> FlattenStream<Self> where
    Self::Output: Stream
[src]

Flatten the execution of this future when the successful result of this future is a stream. Read more

Important traits for Fuse<Fut>
fn fuse(self) -> Fuse<Self>[src]

Fuse a future such that poll will never again be called once it has completed. This method can be used to turn any Future into a FusedFuture. Read more

Important traits for Inspect<Fut, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnOnce(&Self::Output), 
[src]

Do something with the output of a future before passing it on. Read more

Important traits for CatchUnwind<Fut>
fn catch_unwind(self) -> CatchUnwind<Self> where
    Self: UnwindSafe
[src]

Catches unwinding panics while polling the future. Read more

Important traits for Shared<Fut>
fn shared(self) -> Shared<Self> where
    Self::Output: Clone
[src]

Create a cloneable handle to this future where all handles will resolve to the same result. Read more

fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)[src]

Turn this future into a future that yields () on completion and sends its output to another future on a separate task. Read more

Important traits for Pin<P>
fn boxed<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send>> where
    Self: Send + 'a, 
[src]

Wrap the future in a Box, pinning it.

Important traits for Pin<P>
fn boxed_local<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>> where
    Self: 'a, 
[src]

Wrap the future in a Box, pinning it. Read more

Important traits for UnitError<Fut>
fn unit_error(self) -> UnitError<Self>[src]

Turns a Future<Output = T> into a TryFuture<Ok = T, Error = ()>. Read more

Important traits for NeverError<Fut>
fn never_error(self) -> NeverError<Self>[src]

Turns a Future<Output = T> into a TryFuture<Ok = T, Error = !>. Read more

fn poll_unpin(&mut self, cx: &mut Context) -> Poll<Self::Output> where
    Self: Unpin
[src]

A convenience for calling Future::poll on Unpin future types.