Struct flowync::Leaper

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

(Flower without channel)

spring in a long way, jump to a great height, or with great force.

Where:

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

Quick Example:

use flowync::Leaper;

fn main() {
    let leaper = Leaper::<String>::new(1);
    std::thread::spawn({
        let handle = leaper.handle();
        move || {
            // // Return error if the job is failure, for example:
            // 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 {
        // Starting from version 0.2.x instead of polling the mutex over and over,
        // the fn will be activated automatically if the handle return a value
        // and will deactivate itself if the result value successfully catched.
        // Note: this fn is non-blocking (won't block the current thread).
        leaper.try_catch(|result| {
            match result {
                Ok(value) => {
                    println!("{}", value);
                }
                Err(e) => {
                    println!("{}", e);
                }
            }
            exit = true;
        });

        if exit {
            break;
        }
    }
}

Implementations

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

pub fn new(id: usize) -> Self

pub fn id(&self) -> usize

Get ID of the leaper

pub fn handle(&self) -> LeaperHandle<OK>

Get handle of the leaper.

pub fn cancel(&self)

Cancel current leaper handle.

will do noting if not explicitly configured.

pub fn try_catch<Done: FnOnce(Result<OK, String>)>(&self, d: Done)

Try catch the value (result) of the leaper

Trait Implementations

impl<OK> Clone for Leaper<OK> where
    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<OK> Debug for Leaper<OK> where
    OK: Debug + Clone + Send + Sync + 'static, 

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.