Module radiorust::flow

Data flow between blocks

Note: This module still suffers some problems when a lot of values (e.g. Chunks or Samples) are sent at once (e.g. due to reducing the chunk size) because there is currently no backpressure.

Example

The following toy example passes a String from a Producer to a Consumer. For radio applications, you will usually pass Samples instead.

use radiorust::flow::*;

struct MySource {
    sender: Sender<String>,
    /* extra fields can go here */
}
impl Producer<String> for MySource {
    fn connector(&self) -> SenderConnector<'_, String> {
        self.sender.connector()
    }
}

struct MySink {
    receiver: Receiver<String>,
    /* extra fields can go here */
}
impl Consumer<String> for MySink {
    fn receiver(&self) -> &Receiver<String> {
        &self.receiver
    }
}

let src = MySource { sender: Sender::new() };
let dst = MySink { receiver: Receiver::new() };

dst.connect_to_producer(&src);
let mut stream: ReceiverStream<String> = dst.receiver.stream();
src.sender.send("Hello World!".to_string()).await;
assert_eq!(stream.recv().await.unwrap(), "Hello World!".to_string());

Structs

Receiver

Receiver that can be dynamically connected to a Sender

ReceiverStream

Handle that allows retrieving data from a Receiver

Sender

Sender that can be dynamically connected to a Receiver

SenderConnector

Temporary handle to connect a Sender to a Receiver

Enums

RecvError

Error value returned by ReceiverStream::recv

Traits

Consumer

Type which contains a Receiver and can be connected to a Producer

Producer

Type which contains a Sender and can be connected to a Consumer