Struct Extractor

pub struct Extractor { /* private fields */ }

Receives data from an external source and sends the data through a channel.

Using an Extractor yields the following benefits:

• Abstracts away the use of channels. You only need to write a coroutine that takes a parameter and yields a result.
• The coroutine does not have to be aware of termination signals, or joining threads. This functionality is handled by Extractor.
• Easy integration with other Reflux modules.

Example

 #![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
 #![feature(unboxed_closures)]
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use crossbeam_channel::Receiver;
 use reflux::add_routine;
 use reflux::Extractor;
 let stop_flag = Arc::new(AtomicBool::new(false));
 let (extractor, inlet_chan): (Extractor, Receiver<String>) = Extractor::new(
     add_routine!(#[coroutine] |_: ()| {
         yield "Hello, world".to_string()
     }), stop_flag.clone(), None, (), None);

 let data = inlet_chan.recv().unwrap();
 stop_flag.store(true, Ordering::Relaxed);
 extractor.join().unwrap();

 assert_eq!(data, "Hello, world".to_string())

Implementations

impl Extractor

pub fn new<F, C, T, I>( extract_fn: F, stop_sig: Arc<AtomicBool>, pause_sig: Option<Arc<AtomicBool>>, init_data: I, data_limit: Option<usize>, ) -> (Self, Receiver<T>)

where F: Fn() -> C + Send + 'static, I: Send + 'static + Clone, C: Coroutine<I> + Send + 'static + Unpin, T: Send + 'static + From<<C as Coroutine<I>>::Yield>,

Creates a new Extractor object.

Parameters

• extract_fn - A coroutine that reads and returns data from an external source. The use of the add_routine! macro is necessary when passing in an extract_fn.
• pause_sig - A flag to signal the Extractor object to pause execution.
• stop_sig - A flag to signal the Extractor object to terminate execution.

Returns

• A Extractor object.
• AReceiver channel to receive data from the extract_fn.

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

Waits for the Extractor object to finish execution.