Struct ThreadFuture 

pub struct ThreadFuture<T, F, C>
where
    C: CancellationToken + Send + 'static,
{ /* private fields */ }

Create a future that wraps a thread. The thread is lazily created. The thread is not (and cannot be) terminated when this structure is dropped. The thread must behave nicely and check the cancellation token given to see if it should terminate.

Cancellation safety: If the thread is still running when this future is dropped, the thread will not be forcefully terminated, but the cancellation token will be set so that the thread can check it and terminate early if it wants to. If you want to allow the thread to continue running without setting the cancellation token, you can call Self::detach_on_drop or Self::detach_on_drop_ref to prevent the cancellation token from being set on drop.

Implementations

impl<T, F> ThreadFuture<T, F, SimpleCancellationToken>

pub fn new(work: F) -> Self

where F: FnOnce(SimpleCancellationToken) -> T + Send + 'static, T: Send + 'static,

Create a new future-tracked thread using the work function given.

The thread will be lazily spawned on the first poll of this future.

The default SimpleCancellationToken will be provided to the thread work function. Check this token to see if the thread should exit.

See Self::new_eager for eagerly spawning the thread with the default SimpleCancellationToken. See Self::new_with_cancellation for providing a custom cancellation token.

pub fn new_eager(work: F) -> Self

where F: FnOnce(SimpleCancellationToken) -> T + Send + 'static, T: Send + 'static,

Create a new future-tracked thread using the work function given.

The thread will be eagerly spawned during the call to this function.

See Self::new for lazily spawning the thread with the default SimpleCancellationToken. See Self::new_eager_with_cancellation for providing a custom cancellation token.

impl<T, F, C> ThreadFuture<T, F, C>

where F: FnOnce(C) -> T + Send + 'static, T: Send + 'static, C: CancellationToken + Send + 'static,

pub fn new_with_cancellation(work: F, cancellation_token: C) -> Self

Create a new future-tracked thread using the work function given.

The thread will be lazily spawned on the first poll of this future.

Provide a custom cancellation token that implements CancellationToken to share with the thread. The thread can check this token to see if it should exit.

See Self::new_eager for eagerly spawning the thread with the default SimpleCancellationToken. See Self::new_eager_with_cancellation for providing a custom cancellation token.

pub fn new_eager_with_cancellation(work: F, cancellation_token: C) -> Self

Create a new future-tracked thread using the work function given.

The thread will be eagerly spawned during the call to this function.

See Self::new for lazily spawning the thread with the default SimpleCancellationToken. See Self::new_with_cancellation for providing a custom cancellation token.

pub fn detach_on_drop(self) -> Self

When called, will instruct the wrapper to not to activate the cancellation token when dropped.

pub fn detach_on_drop_ref(&mut self)

Same as Self::detach_on_drop, but can be called on a mutable reference to the future instead of consuming it.

pub fn is_cancel_on_drop(&self) -> bool

Check if the cancellation token will be activated when this future is dropped.

pub fn cancellation_token(&self) -> &C

Get a reference to the cancellation token internally stored.

pub fn cancel(&self)

Activate the internal cancellation token.

Trait Implementations

impl<T, F, C> Drop for ThreadFuture<T, F, C>

where C: CancellationToken + Send + 'static,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, F, C> FusedFuture for ThreadFuture<T, F, C>

where F: FnOnce(C) -> T + Send + 'static, T: Send + 'static, C: CancellationToken + Send + 'static,

We know when the future is terminated when the thread has completed, since we will never poll again after that.

The future is not terminated while the thread is still running. This means, even if you activate the cancellation token but the thread has not exited yet, the future is still not terminated.

fn is_terminated(&self) -> bool

Returns true if the underlying future should no longer be polled.

impl<T, F, C> Future for ThreadFuture<T, F, C>

where F: FnOnce(C) -> T + Send + 'static, T: Send + 'static, C: CancellationToken + Send + 'static,

type Output = Result<T, Box<dyn Any + Send>>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

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

impl<'pin, T, F, C> Unpin for ThreadFuture<T, F, C>

where C: CancellationToken + Send + 'static, PinnedFieldsOf<__ThreadFuture<'pin, T, F, C>>: Unpin,