Struct Task 

pub struct Task { /* private fields */ }

A Swift Task this crate started, and owns.

swift_task_create hands the task back at +1 — Swift’s own Task value holds that reference and releases it when the value goes out of scope, and so does this. Dropping the handle while the task is still running is fine: the runtime keeps its own reference until the task completes.

Implementations

impl Task

pub fn is_cancelled(&self) -> bool

Has the task been cancelled?

pub fn cancel(&self)

Ask the task to stop.

Cooperative, as in Swift: it sets a flag the body is expected to check with current_task. Nothing is interrupted.

pub fn priority(&self) -> u32

The task’s base priority, as Swift’s TaskPriority numbers it.

pub fn is_finished(&self) -> bool

Has the closure returned?

Does not block. True once the body has run, whether it returned or panicked.

pub fn wait(&self)

Block until the closure has returned.

A Swift Task’s result is delivered by awaiting it, and Rust has nothing to await from — so the entry signals a condition variable on the way out and this waits on it. That makes a detached task usable from ordinary synchronous Rust, which is what it is for here.

Waiting on the executor’s own thread would deadlock, so do not call this from inside another task.

pub fn wait_timeout(&self, limit: Duration) -> bool

wait with a limit. true if the task finished in time.

Trait Implementations

impl Drop for Task

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for Task

impl Sync for Task