Struct StoppableTask 

pub struct StoppableTask {
    signal: CondVar,
    barrier: CondVar,
    pub task_id: u32,
}

Fields

signal: CondVar

Used to signal to the main running process that it should stop.

barrier: CondVar

When we call stop(), we wait until the process is finished. This is used to prevent stop() from exiting until the task has closed.

task_id: u32

Used so we can keep StoppableTask in HashMap/HashSet

Implementations

impl StoppableTask

A task that can be prematurely stopped at any time.

    let task = StoppableTask::new();
    task.clone().start(
        my_method(),
        |result| self_.handle_stop(result),
        Error::MyStopError,
        executor,
    );

Then at any time we can call task.stop() to close the task.

pub fn new() -> Arc<Self>

pub fn start<'a, MainFut, StopFut, StopFn, Error>( self: Arc<Self>, main: MainFut, stop_handler: StopFn, stop_value: Error, executor: Arc<Executor<'a>>, )

where MainFut: Future<Output = Result<(), Error>> + Send + 'a, StopFut: Future<Output = ()> + Send, StopFn: FnOnce(Result<(), Error>) -> StopFut + Send + 'a, Error: Error + Send + 'a,

Starts the task.

• main is a function of the type async fn foo() -> ()
• stop_handler is a function of the type async fn handle_stop(result: Result<()>) -> ()
• stop_value is the Error code passed to stop_handler when task.stop() is called

pub async fn stop(&self)

Stops the task. On completion, guarantees the process has stopped. Can be called multiple times. After the first call, this does nothing.

pub fn stop_nowait(&self)

Sends a stop signal and returns immediately. Doesn’t guarantee the task stopped on completion.

Trait Implementations

impl Drop for StoppableTask

fn drop(&mut self)

Executes the destructor for this type.

impl Hash for StoppableTask

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for StoppableTask

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for StoppableTask