Struct tokio::task::futures::TaskLocalFuture

pub struct TaskLocalFuture<T, F>
where
    T: 'static,
{
    local: &'static LocalKey<T>,
    slot: Option<T>,
    future: Option<F>,
    _pinned: PhantomPinned,
}

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;

Fields

local: &'static LocalKey<T>

slot: Option<T>

future: Option<F>

_pinned: PhantomPinned

Implementations

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

where T: 'static,

pub fn take_value(self: Pin<&mut Self>) -> 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: Debug + 'static,

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

Formats the value using the given formatter.

impl<T: 'static, F> Drop for TaskLocalFuture<T, F>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: 'static, F: Future> Future for TaskLocalFuture<T, F>

type Output = <F as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::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 PinnedFieldsOf<__Origin<'__pin, T, F>>: Unpin, T: 'static,