Struct fuchsia_async::atomic_future::AtomicFuture

pub struct AtomicFuture<'a> { /* private fields */ }

A lock-free thread-safe future.

Implementations

impl<'a> AtomicFuture<'a>

pub fn new<F: Future<Output = R> + Send + 'a, R: Send + 'a>( future: F, detached: bool ) -> Self

Create a new AtomicFuture.

pub unsafe fn new_local<F: Future<Output = R> + 'a, R: 'a>( future: F, detached: bool ) -> Self

Create a new AtomicFuture from a !Send future.

Safety

The caller must uphold the Send requirements.

pub fn try_poll(&self, cx: &mut Context<'_>) -> AttemptPollResult

Attempt to poll the underlying future.

try_poll ensures that the future is polled at least once more unless it has already finished.

pub fn mark_ready(&self) -> bool

Marks the future as ready and returns true if it needs to be added to a run queue, i.e. it isn’t already ready, active or done.

pub unsafe fn drop_future_unchecked(&self)

Drops the future without checking its current state.

Safety

This doesn’t check the current state, so this must only be called if it is known that there is no concurrent access. This also does not include any memory barriers before dropping the future.

pub fn try_drop(&self) -> Result<(), ()>

Drops the future if it is not currently being polled. Returns success if the future was dropped or was already dropped.

pub fn cancel(&self) -> bool

Cancels the task. Returns true if the task needs to be added to a run queue.

pub fn detach(&self)

Marks the task as detached.

pub fn is_detached_or_cancelled(&self) -> bool

Returns true if the task is detached or cancelled.

pub unsafe fn take_result<R>(&self) -> Option<R>

Takes the result.

Safety

The caller must guarantee that R is the correct type.

Trait Implementations

impl Drop for AtomicFuture<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl Send for AtomicFuture<'_>

impl Sync for AtomicFuture<'_>

AtomicFuture is safe to access from multiple threads at once.