Struct tokio_stream::StreamNotifyClose

pub struct StreamNotifyClose<S> { /* private fields */ }

A Stream that wraps the values in an Option.

Whenever the wrapped stream yields an item, this stream yields that item wrapped in Some. When the inner stream ends, then this stream first yields a None item, and then this stream will also end.

Example

Using StreamNotifyClose to handle closed streams with StreamMap.

use tokio_stream::{StreamExt, StreamMap, StreamNotifyClose};

#[tokio::main]
async fn main() {
    let mut map = StreamMap::new();
    let stream = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
    let stream2 = StreamNotifyClose::new(tokio_stream::iter(vec![0, 1]));
    map.insert(0, stream);
    map.insert(1, stream2);
    while let Some((key, val)) = map.next().await {
        match val {
            Some(val) => println!("got {val:?} from stream {key:?}"),
            None => println!("stream {key:?} closed"),
        }
    }
}

Implementations

impl<S> StreamNotifyClose<S>

pub fn new(stream: S) -> Self

Create a new StreamNotifyClose.

pub fn into_inner(self) -> Option<S>

Get back the inner Stream.

Returns None if the stream has reached its end.

Trait Implementations

impl<S> Stream for StreamNotifyClose<S>

where S: Stream,

type Item = Option<<S as Stream>::Item>

Values yielded by the stream.

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

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'__pin, S> Unpin for StreamNotifyClose<S>

where __Origin<'__pin, S>: Unpin,