Struct MergeUnbounded

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

A combined stream that releases values in any order that they come.

This differs from crate::Merge in that MergeUnbounded does not have a fixed capacity but instead grows on demand. It uses crate::FuturesUnordered under the hood.

Example

use std::future::ready;
use futures::stream::{self, StreamExt};
use futures::executor::block_on;
use futures_buffered::MergeUnbounded;

block_on(async {
    let a = stream::once(ready(2));
    let b = stream::once(ready(3));
    let mut s = MergeUnbounded::from_iter([a, b]);

    let mut counter = 0;
    while let Some(n) = s.next().await {
        if n == 3 {
            s.push(stream::once(ready(4)));
        }
        counter += n;
    }
    assert_eq!(counter, 2+3+4);
})

Implementations

impl<S> MergeUnbounded<S>

pub const fn new() -> Self

Create a new, empty MergeUnbounded.

Calling poll_next will return Poll::Ready(None) until a stream is added with Self::push.

pub fn push(&mut self, stream: S)

Push a stream into the set.

This method adds the given stream to the set. This method will not call poll_next on the submitted stream. The caller must ensure that MergeUnbounded::poll_next is called in order to receive wake-up notifications for the given stream.

pub fn is_empty(&self) -> bool

Returns true if there are no streams in the set.

pub fn len(&self) -> usize

Returns the number of streams currently in the set.

Trait Implementations

impl<S> Default for MergeUnbounded<S>

fn default() -> Self

Returns the “default value” for a type.

impl<S: Stream + Unpin> FromIterator<S> for MergeUnbounded<S>

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = S>,

Creates a value from an iterator.

impl<S: Stream + Unpin> Stream for MergeUnbounded<S>

type Item = <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.