Struct CancellationTokenWrapper 

pub struct CancellationTokenWrapper {
    pub token: CancellationToken,
}

Fields

token: CancellationToken

Implementations

impl CancellationTokenWrapper

pub const js_cancel: __impl_cancel = __impl_cancel

impl CancellationTokenWrapper

pub fn cancel(&self)

pub fn new()

Methods from Deref<Target = CancellationToken>

pub fn child_token(&self) -> CancellationToken

Creates a CancellationToken which will get cancelled whenever the current token gets cancelled. Unlike a cloned CancellationToken, cancelling a child token does not cancel the parent token.

If the current token is already cancelled, the child token will get returned in cancelled state.

Examples

use tokio::select;
use tokio_util::sync::CancellationToken;

#[tokio::main]
async fn main() {
    let token = CancellationToken::new();
    let child_token = token.child_token();

    let join_handle = tokio::spawn(async move {
        // Wait for either cancellation or a very long time
        select! {
            _ = child_token.cancelled() => {
                // The token was cancelled
                5
            }
            _ = tokio::time::sleep(std::time::Duration::from_secs(9999)) => {
                99
            }
        }
    });

    tokio::spawn(async move {
        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
        token.cancel();
    });

    assert_eq!(5, join_handle.await.unwrap());
}

pub fn cancel(&self)

Cancel the CancellationToken and all child tokens which had been derived from it.

This will wake up all tasks which are waiting for cancellation.

Be aware that cancellation is not an atomic operation. It is possible for another thread running in parallel with a call to cancel to first receive true from is_cancelled on one child node, and then receive false from is_cancelled on another child node. However, once the call to cancel returns, all child nodes have been fully cancelled.

pub fn is_cancelled(&self) -> bool

Returns true if the CancellationToken is cancelled.

pub fn cancelled(&self) -> WaitForCancellationFuture<'_>

Returns a Future that gets fulfilled when cancellation is requested.

Equivalent to:

async fn cancelled(&self);

The future will complete immediately if the token is already cancelled when this method is called.

Cancellation safety

This method is cancel safe.

pub fn drop_guard_ref(&self) -> DropGuardRef<'_>

Creates a DropGuardRef for this token.

Returned guard will cancel this token (and all its children) on drop unless disarmed.

pub async fn run_until_cancelled<F>( &self, fut: F, ) -> Option<<F as Future>::Output>

where F: Future,

Runs a future to completion and returns its result wrapped inside of an Option unless the CancellationToken is cancelled. In that case the function returns None and the future gets dropped.

Fairness

Calling this on an already-cancelled token directly returns None. For all subsequent polls, in case of concurrent completion and cancellation, this is biased towards the future completion.

Cancellation safety

This method is only cancel safe if fut is cancel safe.

Trait Implementations

impl Clone for CancellationTokenWrapper

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'js> ConstructorCreator<'js, CancellationTokenWrapper> for ConstructorCreate<CancellationTokenWrapper>

fn create_constructor(&self, ctx: &Ctx<'js>) -> Result<Option<Constructor<'js>>>

impl Debug for CancellationTokenWrapper

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

Formats the value using the given formatter.

impl Deref for CancellationTokenWrapper

type Target = CancellationToken

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for CancellationTokenWrapper

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<CancellationToken> for CancellationTokenWrapper

fn from(value: CancellationToken) -> Self

Converts to this type from the input type.

impl From<CancellationTokenWrapper> for CancellationToken

fn from(value: CancellationTokenWrapper) -> Self

Converts to this type from the input type.

impl<'js> FromJs<'js> for CancellationTokenWrapper

where for<'a> CloneWrapper<'a, Self>: CloneTrait<Self>,

fn from_js(ctx: &Ctx<'js>, value: Value<'js>) -> Result<Self>

impl<'js> IntoJs<'js> for CancellationTokenWrapper

fn into_js(self, ctx: &Ctx<'js>) -> Result<Value<'js>>

impl<'js> JsClass<'js> for CancellationTokenWrapper

const NAME: &'static str = "CancellationToken"

The name the constructor has in JavaScript

type Mutable = Writable

Can the type be mutated while a JavaScript value.

fn prototype(ctx: &Ctx<'js>) -> Result<Option<Object<'js>>>

Returns the class prototype,

fn constructor(ctx: &Ctx<'js>) -> Result<Option<Constructor<'js>>>

Returns a predefined constructor for this specific class type if there is one.

const CALLABLE: bool = false

Is this class a function.

fn call<'a>( this: &JsCell<'js, Self>, params: Params<'a, 'js>, ) -> Result<Value<'js>, Error>

The function which will be called if Self::CALLABLE is true and an an object with this class is called as if it is a function.

impl<'js> JsLifetime<'js> for CancellationTokenWrapper

type Changed<'to> = CancellationTokenWrapper

The target which has the same type as a Self but with another lifetime 't

impl MethodImplementor<CancellationTokenWrapper> for MethodImpl<CancellationTokenWrapper>

fn implement(&self, _proto: &Object<'_>) -> Result<()>

impl<'js> Trace<'js> for CancellationTokenWrapper

fn trace<'a>(&self, _tracer: Tracer<'a, 'js>)