Struct Router

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

An object that received data from a provided Receiver, and broadcasts the data to subscribers using a Round Robin algorithm.

Using a Router yields the following benefits:

• Distribute data among multiple receivers, thus ensuring an even distribution of workload.

Example

 #![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
 #![feature(unboxed_closures)]
 use reflux::Router;
 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 stop_flag = Arc::new(AtomicBool::new(false));
         
 let (tx, rx) = unbounded();
         
 let mut router = Router::new(rx, None, stop_flag.clone());
         
 let (in1, out1) = unbounded();
 let (in2, out2) = unbounded();
         
 router.subscribe(in1);
 router.subscribe(in2);
         
 tx.send("hello".to_string()).unwrap();
 tx.send("there".to_string()).unwrap();
 tx.send("beautiful".to_string()).unwrap();
 tx.send("world".to_string()).unwrap();
         
 let out1_res = out1.recv().unwrap();
 let out2_res = out2.recv().unwrap();
 let out3_res = out1.recv().unwrap();
 let out4_res = out2.recv().unwrap();
         
 assert_eq!(out1_res, "hello".to_string());
 assert_eq!(out2_res, "there".to_string());
 assert_eq!(out3_res, "beautiful".to_string());
 assert_eq!(out4_res, "world".to_string());

Implementations

impl<T> Router<T>

where T: Send + 'static,

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

Creates a new Router object.

Parameters

• source - The source of data that needs to be routed.
• pause_sig - A flag to signal the Router object to pause execution.
• stop_sig - A flag to signal the Router object to terminate execution.

Returns

A Router object.

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

Add a subscriber to the Router.

Parameters

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

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

Waits for the Router object to finish execution.