# Struct futures_util::stream::StreamFuture [−] [src]

    #[must_use = "futures do nothing unless you `.await` or poll them"]pub struct StreamFuture<St> { /* fields omitted */ }

Future for the `into_future` method.

## Implementations

### `impl<St: Stream + Unpin> StreamFuture<St>` [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<&mut Self>) -> Option<Pin<&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: Debug> Debug for StreamFuture<St>` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<St: Stream + Unpin> FusedFuture for StreamFuture<St>` [src]

#### `fn is_terminated(&self) -> bool` [src]

Returns `true` if the underlying future should no longer be polled.

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

#### `type Output = (Option<St::Item>, St)`

The type of value produced on completion.

#### `fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>` [src]

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

## Auto Trait Implementations

### `impl<St> RefUnwindSafe for StreamFuture<St> where
St: RefUnwindSafe,`

### `impl<St> Send for StreamFuture<St> where
St: Send,`

### `impl<St> Sync for StreamFuture<St> where
St: Sync,`

### `impl<St> Unpin for StreamFuture<St> where
St: Unpin,`

### `impl<St> UnwindSafe for StreamFuture<St> where
St: UnwindSafe,`

## Blanket Implementations

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

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

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

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

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

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

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

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

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

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<F> IntoFuture for F where
F: Future,` [src]

#### `type Output = <F as Future>::Output`

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

The output that the future will produce on completion.

#### `type Future = F`

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

Which kind of future are we turning this into?

#### `pub fn into_future(self) -> <F as IntoFuture>::Future` [src]

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

Creates a future from a value.

### `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.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `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.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.