`impl<St, Fut> TakeUntil<St, Fut>`

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.

fn take_future(self: &mut Self) -> Option<Fut>

Extract the stopping future out of the combinator. The future is returned only if it isn't resolved yet, ie. if the stream isn't stopped yet. Taking out the future means the combinator will be yielding elements from the wrapped stream without ever stopping it.

fn take_result(self: &mut Self) -> Option<<Fut as >::Output>

Once the stopping future is resolved, this method can be used to extract the value returned by the stopping future.

This may be used to retrieve arbitrary data from the stopping future, for example a reason why the stream was stopped.

This method will return None if the future isn't resolved yet, or if the result was already taken out.

Examples

# futures::executor::block_on(async {
use futures::future;
use futures::stream::{self, StreamExt};
use futures::task::Poll;

let stream = stream::iter(1..=10);

let mut i = 0;
let stop_fut = future::poll_fn(|_cx| {
    i += 1;
    if i <= 5 {
        Poll::Pending
    } else {
        Poll::Ready("reason")
    }
});

let mut stream = stream.take_until(stop_fut);
let _ = stream.by_ref().collect::<Vec<_>>().await;

let result = stream.take_result().unwrap();
assert_eq!(result, "reason");
# });

fn is_stopped(self: &Self) -> bool

Whether the stream was stopped yet by the stopping future being resolved.

`impl<'__pin, St: Stream, Fut: Future> Unpin for TakeUntil<St, Fut>`

`impl<S> TryStreamExt for TakeUntil<St, Fut>`

`impl<S, Fut, Item> Sink for TakeUntil<S, Fut>`

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, T, E> TryStream for TakeUntil<St, Fut>`

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

`impl<St, Fut> Debug for TakeUntil<St, Fut>`

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

`impl<St, Fut> Freeze for TakeUntil<St, Fut>`

`impl<St, Fut> FusedStream for TakeUntil<St, Fut>`

fn is_terminated(self: &Self) -> bool

`impl<St, Fut> RefUnwindSafe for TakeUntil<St, Fut>`

`impl<St, Fut> Send for TakeUntil<St, Fut>`

`impl<St, Fut> Stream for TakeUntil<St, Fut>`

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

`impl<St, Fut> Sync for TakeUntil<St, Fut>`

`impl<St, Fut> UnsafeUnpin for TakeUntil<St, Fut>`

`impl<St, Fut> UnwindSafe for TakeUntil<St, Fut>`

`impl<T> Any for TakeUntil<St, Fut>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for TakeUntil<St, Fut>`

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

`impl<T> BorrowMut for TakeUntil<St, Fut>`

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

`impl<T> From for TakeUntil<St, Fut>`

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

`impl<T> StreamExt for TakeUntil<St, Fut>`

`impl<T, Item> SinkExt for TakeUntil<St, Fut>`

`impl<T, U> Into for TakeUntil<St, Fut>`

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 TakeUntil<St, Fut>`

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

`impl<T, U> TryInto for TakeUntil<St, Fut>`

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

Struct `TakeUntil`

Implementations