Struct MergeBounded

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

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

Example

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

block_on(async {
    let a = stream::once(ready(2));
    let b = stream::once(ready(3));
    let c = stream::once(ready(5));
    let d = stream::once(ready(7));
    let mut s = Merge::from_iter([a, b, c, d]);

    let mut counter = 0;
    while let Some(n) = s.next().await {
        counter += n;
    }
    assert_eq!(counter, 2+3+5+7);
})

Implementations

impl<S> MergeBounded<S>

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 Merge::poll_next is called in order to receive wake-up notifications for the given stream.

Panics

This method will panic if the buffer is currently full. See Merge::try_push to get a result instead

pub fn try_push(&mut self, stream: S) -> Result<(), S>

Push a future into the set.

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

Errors

This method will error if the buffer is currently full, returning the future back

Trait Implementations

impl<S: Stream> FromIterator<S> for MergeBounded<S>

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

where T: IntoIterator<Item = S>,

Creates a value from an iterator.

impl<S: Stream> Stream for MergeBounded<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.