Struct ReceiverStreamBuilder 

pub(crate) struct ReceiverStreamBuilder<O> {
    tx: Sender<Result<O>>,
    rx: Receiver<Result<O>>,
    join_set: JoinSet<Result<()>>,
}

Creates a stream from a collection of producing tasks, routing panics to the stream.

Note that this is similar to ReceiverStream from tokio-stream, with the differences being:

1. Methods to bound and “detach” tasks (spawn() and spawn_blocking()).

2. Propagates panics, whereas the tokio version doesn’t propagate panics to the receiver.

3. Automatically cancels any outstanding tasks when the receiver stream is dropped.

Fields

tx: Sender<Result<O>>

rx: Receiver<Result<O>>

join_set: JoinSet<Result<()>>

Implementations

impl<O: Send + 'static> ReceiverStreamBuilder<O>

pub fn new(capacity: usize) -> Self

Create new channels with the specified buffer size

pub fn tx(&self) -> Sender<Result<O>>

Get a handle for sending data to the output

pub fn spawn<F>(&mut self, task: F)

where F: Future<Output = Result<()>> + Send + 'static,

Spawn task that will be aborted if this builder (or the stream built from it) are dropped

pub fn spawn_on<F>(&mut self, task: F, handle: &Handle)

where F: Future<Output = Result<()>> + Send + 'static,

Same as Self::spawn but it spawns the task on the provided runtime

pub fn spawn_blocking<F>(&mut self, f: F)

where F: FnOnce() -> Result<()> + Send + 'static,

Spawn a blocking task that will be aborted if this builder (or the stream built from it) are dropped.

This is often used to spawn tasks that write to the sender retrieved from Self::tx.

pub fn spawn_blocking_on<F>(&mut self, f: F, handle: &Handle)

where F: FnOnce() -> Result<()> + Send + 'static,

Same as Self::spawn_blocking but it spawns the blocking task on the provided runtime

pub fn build(self) -> BoxStream<'static, Result<O>>

Create a stream of all data written to tx