Struct catalyzer::internals::crates::tokio::task::futures::TaskLocalFuture

pub struct TaskLocalFuture<T, F>
where
    T: 'static,
{ /* private fields */ }

A future that sets a value T of a task local for the future F during its execution.

The value of the task-local must be 'static and will be dropped on the completion of the future.

Created by the function LocalKey::scope.

Examples

tokio::task_local! {
    static NUMBER: u32;
}

NUMBER.scope(1, async move {
    println!("task local value: {}", NUMBER.get());
}).await;

Implementations

impl<T, F> TaskLocalFuture<T, F>

where T: 'static,

pub fn take_value(self: Pin<&mut TaskLocalFuture<T, F>>) -> Option<T>

Returns the value stored in the task local by this TaskLocalFuture.

The function returns:

• Some(T) if the task local value exists.
• None if the task local value has already been taken.

Note that this function attempts to take the task local value even if the future has not yet completed. In that case, the value will no longer be available via the task local after the call to take_value.

Examples

tokio::task_local! {
    static KEY: u32;
}

let fut = KEY.scope(42, async {
    // Do some async work
});

let mut pinned = Box::pin(fut);

// Complete the TaskLocalFuture
let _ = pinned.as_mut().await;

// And here, we can take task local value
let value = pinned.as_mut().take_value();

assert_eq!(value, Some(42));

Trait Implementations

impl<T, F> Debug for TaskLocalFuture<T, F>

where T: 'static + Debug,

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

Formats the value using the given formatter.

impl<T, F> Drop for TaskLocalFuture<T, F>

where T: 'static,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, F> Future for TaskLocalFuture<T, F>

where T: 'static, F: Future,

type Output = <F as Future>::Output

The type of value produced on completion.

fn poll( self: Pin<&mut TaskLocalFuture<T, F>>, cx: &mut Context<'_> ) -> Poll<<TaskLocalFuture<T, F> 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.

impl<'__pin, T, F> Unpin for TaskLocalFuture<T, F>

where __Origin<'__pin, T, F>: Unpin, T: 'static,