Struct reflux::Broadcast

pub struct Broadcast<T> { /* private fields */ }

An object that received data from a provided Receiver, and broadcasts the data to all subscribers.

Using a Broadcast yields the following benefits:

• Send received data to multiple endpoint. A Broadcast object can be used to build a web of objects.

Example

 #![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
 #![feature(unboxed_closures)]
 use reflux::{Inlet, Outlet, Broadcast};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use crossbeam_channel::Receiver;
 use reflux::add_routine;
 use crossbeam_channel::unbounded;
 use std::time::Duration;
 use std::thread::sleep;
 let stop_flag = Arc::new(AtomicBool::new(false));
 
 let test_inlet: (Inlet, Receiver<String>) = Inlet::new(add_routine!(#[coroutine] || {
            sleep(Duration::from_secs(1));
            yield "hello".to_string()
        }), stop_flag.clone(), ());
 
 let (test_outlet1_sink, test_outlet1_source) = unbounded();
 let (test_outlet2_sink, test_outlet2_source) = unbounded();
 
 let (test_outlet1, test1_tx) = Outlet::new(move |example: String| {
    test_outlet1_sink.send(format!("1: {example}")).unwrap()
 }, stop_flag.clone());
 
 let (test_outlet2, test2_tx) = Outlet::new(move |example: String| {
     test_outlet2_sink.send(format!("2: {example}")).unwrap()
 }, stop_flag.clone());
 
 let mut broadcaster = Broadcast::new(test_inlet.1, stop_flag.clone());
 broadcaster.subscribe(test1_tx);
 broadcaster.subscribe(test2_tx);
 
 let data1 = test_outlet1_source.recv().unwrap();
 let data2 = test_outlet2_source.recv().unwrap();
 
 stop_flag.store(true, Ordering::Relaxed);
 
 test_outlet1.join().unwrap();
 test_outlet2.join().unwrap();
 test_inlet.0.join().unwrap();
 broadcaster.join().unwrap();
 
 
 assert_eq!(data1, "1: hello".to_string());
 assert_eq!(data2, "2: hello".to_string());

Implementations

impl<T> Broadcast<T>

where T: Clone + Send + 'static,

pub fn new(source: Receiver<T>, stop_sig: Arc<AtomicBool>) -> Self

Creates a new Broadcast object.

Parameters

• source - The source of data that needs to be broadcast
• stop_sig - A flag to signal the Broadcast object to terminate

Returns

A Broadcast object

pub fn subscribe(&mut self, subscriber: Sender<T>)

Add a subscriber to the Broadcast

Parameters

• subscriber - A Sender with which to send data to.

pub fn channel(&mut self) -> Receiver<T>

Create a subscription for an external object to use to receive data from the Broadcast. Note: Subscription is based on an unbounded channel.

Returns

• A Receiver object from which to receive data.

pub fn channel_bounded(&mut self, data_limit: Option<usize>) -> Receiver<T>

Create a subscription for an external object to use to receive data from the Broadcast. Note: Subscription is based on a bounded channel.

Returns

• A Receiver object from which to receive data.

pub fn join(self) -> Result<()>

Waits for the Broadcast object to finish execution