Struct flowync::Flower

pub struct Flower<S, R>where
    S: Send,
    R: Send,{ /* private fields */ }

Flow loosely and gracefully.

Where:

S = type of sender (channel) value

R = type of Ok value of the Result (Result<R, String>, and Err value always return String)

Quick Example:

 use flowync::{Flower, IOError};
 type TestFlower = Flower<u32, String>;

 fn fetch_things(id: usize) -> Result<String, IOError> {
     let result =
         Ok::<String, IOError>(format!("the flower with id: {} successfully completed fetching.", id));
     let success = result?;
     Ok(success)
 }

 fn main() {
     let flower: TestFlower = Flower::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,
             }
             let result = fetch_things(handle.id());
             // Set result and then extract later.
             handle.set_result(result)
         }
     });

     let mut exit = false;

     loop {
         // Check if the flower is_active()
         // and will deactivate itself if the result value successfully received.
         if flower.is_active() {
             // another logic goes here...
             // e.g:
             // notify_loading_fn();

             flower
                 .extract(|channel| {
                     // Poll channel
                     if let Some(value) = channel {
                         println!("{}", value);
                     }
                 })
                 .finalize(|result| {
                     match result {
                         Ok(value) => println!("{}", value),
                         Err(err_msg) => println!("{}", err_msg),
                     }
                     // Exit if finalized
                     exit = true;
                 });
         }

         if exit {
             break;
         }
     }
 }

Implementations

impl<S, R> Flower<S, R>where
    S: Send,
    R: Send,

pub fn new(id: usize) -> Self

pub fn id(&self) -> usize

Get ID of the flower.

pub fn handle(&self) -> Handle<S, R>

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 result(&self, f: impl FnOnce(Result<R, String>))

👎Deprecated: result is highly deprecated, use try_result fn is instead

pub fn try_result(&self, f: impl FnOnce(Result<R, String>))

Try get the result of the flower and ignore channel value (if any).

Warning! don’t use this fn if channel value is important, use extract fn and then use finalize fn instead.

pub fn extract(&self, f: impl FnOnce(Option<S>)) -> Extracted<'_, S, R>

Try extract channel value of the flower if available, and then finalize (must_use)

Trait Implementations

impl<S, R> Clone for Flower<S, R>where
    S: Send,
    R: Send,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, R> Debug for Flower<S, R>where
    S: Debug + Send,
    R: Debug + Send,

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

Formats the value using the given formatter.

impl<S, R> Drop for Flower<S, R>where
    S: Send,
    R: Send,

fn drop(&mut self)

Executes the destructor for this type.