Struct Expectation

pub struct Expectation<T> { /* private fields */ }

Implementations

impl<T> Expectation<T>

where T: Send + 'static,

pub fn is_cancelled(&self) -> bool

Show whether the task is cancelled.

pub fn is_done(&self) -> bool

Show whether the task is done.

pub fn cancel(&mut self) -> Result<(), ExecutorError>

Cancel the task when the task is still waiting in line.

If the task is started running, Err will be return.

If the task is already cancel, Err will be return.

pub fn get_result(&mut self) -> Result<T, ExecutorError>

This method returns a Result which will return the return value of your closure when Ok, and Err will be returned when your closure panic.

Example

let pool = threadpool_executor::ThreadPool::new(1);
let exp = pool.execute(|| 1 + 2);
assert_eq!(exp.unwrap().get_result().unwrap(), 3);

When panic:

let pool = threadpool_executor::ThreadPool::new(1);
let exp = pool.execute(|| {
    panic!("panic!!!");
});
let res = exp.unwrap().get_result();
assert!(res.is_err());
if let Err(err) = res {
    matches!(err.kind(), threadpool_executor::error::ErrorKind::Panic);
}

pub fn get_result_timeout( &mut self, timeout: Duration, ) -> Result<T, ExecutorError>

This method returns a Result which will return the return value of your closure when Ok, and Err will be returned when your closure panic or timeout.

Example

let pool = threadpool_executor::ThreadPool::new(1);
let exp = pool.execute(|| 1 + 2);
assert_eq!(exp.unwrap().get_result_timeout(std::time::Duration::from_secs(1)).unwrap(), 3);

When timeout:

use std::time::Duration;
let pool = threadpool_executor::ThreadPool::new(1);
let exp = pool.execute(|| {
    std::thread::sleep(Duration::from_secs(3));
});
let res = exp.unwrap().get_result_timeout(Duration::from_secs(1));
assert!(res.is_err());
if let Err(err) = res {
    matches!(err.kind(), threadpool_executor::error::ErrorKind::TimeOut);
}

Trait Implementations

impl<T> Drop for Expectation<T>

fn drop(&mut self)

Executes the destructor for this type.