Struct flowync::Flower

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

Flow loosely and gracefully.

Where:

SOME: type of sender (channel) value

OK: type of Ok value of the Result (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();
        // Activate
        handle.activate();
        move || {
            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(i);
                // or handle.send_async(i).await; can be used from any multithreaded async runtime,
                
                // // 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 {
        // instead of polling the mutex over and over,
        // the fn will be activated automatically if the handle sending or return a value
        // and will deactivate itself if the result value successfully received.
        // Note: this fn is non-blocking (won't block the current thread).
        if flower.is_active() {
            flower.try_recv(|channel| {
                if let Some(value) = channel {
                    println!("{}", value);
                }
            }).on_complete(|result| match result {
                Ok(value) => println!("{}", value),
                Err(err_msg) => println!("{}", err_msg),
            });
        }

        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 cancel(&self)

Cancel current flower handle.

will do nothing if not explicitly configured.

pub fn is_canceled(&self) -> bool

Check if the flower is canceled

pub fn is_active(&self) -> bool

Check if the current flower is active

pub fn result_is_ready(&self) -> bool

Check if result value of the flower is ready

pub fn channel_is_present(&self) -> bool

Check if channel value of the flower is present

pub fn try_recv(&self, f: impl FnOnce(Option<SOME>)) -> &Self

Try receive the flower channel value

pub fn on_complete(&self, f: impl FnOnce(Result<OK, String>))

Process the flower result

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.