Struct bevy_internal::tasks::Task

pub struct Task<T>(/* private fields */);

Wraps async_executor::Task, a spawned future.

Tasks are also futures themselves and yield the output of the spawned future.

When a task is dropped, its gets canceled and won’t be polled again. To cancel a task a bit more gracefully and wait until it stops running, use the Task::cancel() method.

Tasks that panic get immediately canceled. Awaiting a canceled task also causes a panic. Wraps async_executor::Task

Implementations

impl<T> Task<T>

pub fn new(task: Task<T>) -> Task<T>

Creates a new task from a given async_executor::Task

pub fn detach(self)

Detaches the task to let it keep running in the background. See async_executor::Task::detach

pub async fn cancel(self) -> Option<T>

Cancels the task and waits for it to stop running.

Returns the task’s output if it was completed just before it got canceled, or None if it didn’t complete.

While it’s possible to simply drop the Task to cancel it, this is a cleaner way of canceling because it also waits for the task to stop running.

See async_executor::Task::cancel

pub fn is_finished(&self) -> bool

Returns true if the current task is finished.

Unlike poll, it doesn’t resolve the final value, it just checks if the task has finished. Note that in a multithreaded environment, this task can be finished immediately after calling this function.

Trait Implementations

impl<T> Debug for Task<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Future for Task<T>

type Output = T

The type of value produced on completion.

fn poll( self: Pin<&mut Task<T>>, cx: &mut Context<'_> ) -> Poll<<Task<T> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.