Fuse - futures

`impl<St> Fuse<St>`

fn is_done(self: &Self) -> bool

Returns whether the underlying stream has finished or not.

If this method returns true, then all future calls to poll are guaranteed to return None. If this returns false, then the underlying stream is still in use.

fn get_ref(self: &Self) -> &St

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

fn get_mut(self: &mut Self) -> &mut St

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

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

fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut St>

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

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

fn into_inner(self: Self) -> St

Consumes this combinator, returning the underlying sink or stream.

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

`impl<'__pin, St> Unpin for Fuse<St>`

`impl<S> TryStreamExt for Fuse<St>`

`impl<S, T, E> TryStream for Fuse<St>`

fn try_poll_next(self: Pin<&mut S>, cx: &mut Context<'_>) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>

`impl<S: Stream + Sink<Item>, Item> Sink for Fuse<S>`

fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), <Self as >::Error>>
fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), <Self as >::Error>
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), <Self as >::Error>>
fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), <Self as >::Error>>

`impl<S: Stream> FusedStream for Fuse<S>`

fn is_terminated(self: &Self) -> bool

`impl<S: Stream> Stream for Fuse<S>`

fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<<S as >::Item>>
fn size_hint(self: &Self) -> (usize, Option<usize>)

`impl<St> Freeze for Fuse<St>`

`impl<St> RefUnwindSafe for Fuse<St>`

`impl<St> Send for Fuse<St>`

`impl<St> Sync for Fuse<St>`

`impl<St> UnsafeUnpin for Fuse<St>`

`impl<St> UnwindSafe for Fuse<St>`

`impl<St: $crate::fmt::Debug> Debug for Fuse<St>`

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

`impl<T> Any for Fuse<St>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Fuse<St>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Fuse<St>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for Fuse<St>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> StreamExt for Fuse<St>`

`impl<T, Item> SinkExt for Fuse<St>`

`impl<T, U> Into for Fuse<St>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Fuse<St>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Fuse<St>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

Struct `Fuse`

Implementations