Struct flowync::Flower

pub struct Flower<SOME, OK> where
    SOME: Clone + Send + Sync + 'static,
    OK: Clone + Send + Sync + 'static,  { /* fields omitted */ }

Flow loosely and gracefully.

Where:

SOME: type of Some value (Option<‘SOME’>)

OK: type of Ok value (Result<‘OK’, String>, and Err value always return String)

Quick Example:

use flowync::Flower;

fn main() {
    let flower = Flower::<i32, String>::new(1);
    std::thread::spawn({
        let handle = flower.handle();
        move || {
            // Start flowing to initialize.
            handle.start_flowing();
            for i in 0..10 {
                // Send current value through channel, will block the spawned thread
                // until the option value successfully being polled in the main thread.
                handle.send_current(i);
                // // Return error if the job is failure, for example:
                // if i >= 3 {
                //    return handle.err("Err".to_string());
                // }
            }
            // And return ok if the job successfully completed.
            return handle.ok("Ok".to_string());
        }
    });

    let mut exit = false;

    loop {
        // This fn will deactivate itself if the result contains a value.
        // Note: this fn is non-blocking (won't block the current thread).
        flower.try_recv(
            |option| {
                if let Some(value) = option {
                    println!("{}", value);
                }
            },
            |result| {
                match result {
                    Ok(value) => {
                        println!("{}", value);
                    }
                    Err(e) => {
                        println!("{}", e);
                    }
                }
                exit = true;
            },
        );

        if exit {
            break;
        }
    }
}

Implementations

impl<SOME, OK> Flower<SOME, OK> where
    SOME: Clone + Send + Sync + 'static,
    OK: Clone + Send + Sync + 'static, 

pub fn new(id: usize) -> Self

pub fn id(&self) -> usize

Get ID of the flower.

pub fn handle(&self) -> FlowerHandle<SOME, OK>

Get handle of the flower.

pub fn is_flowing(&self) -> bool

Check if the flower is flowing

pub fn cancel(&self)

Cancel current flower handle.

will do noting if not explicitly configured.

pub fn try_recv<Current: FnOnce(Option<SOME>), Done: FnOnce(Result<OK, String>)>(
    &self,
    c: Current,
    d: Done
)

Try receive the contained values of the flower

Trait Implementations

impl<SOME, OK> Clone for Flower<SOME, OK> where
    SOME: Clone + Send + Sync + 'static,
    OK: Clone + Send + Sync + 'static, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<SOME, OK> Debug for Flower<SOME, OK> where
    SOME: Debug + Clone + Send + Sync + 'static,
    OK: Debug + Clone + Send + Sync + 'static, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<SOME, OK> Drop for Flower<SOME, OK> where
    SOME: Clone + Send + Sync + 'static,
    OK: Clone + Send + Sync + 'static, 

fn drop(&mut self)

Executes the destructor for this type.