Struct `TaskLocalFuture`

struct TaskLocalFuture<T, F> { ... }
where
    T: 'static

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

# async fn dox() {
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>`

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

# async fn dox() {
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));
# }

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

`impl<F> IntoFuture for TaskLocalFuture<T, F>`

fn into_future(self: Self) -> <F as IntoFuture>::IntoFuture

`impl<T> Any for TaskLocalFuture<T, F>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for TaskLocalFuture<T, F>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for TaskLocalFuture<T, F>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for TaskLocalFuture<T, F>`

fn from(t: T) -> T: Returns the argument unchanged.

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

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

`impl<T, F> Freeze for TaskLocalFuture<T, F>`

`impl<T, F> RefUnwindSafe for TaskLocalFuture<T, F>`

`impl<T, F> Send for TaskLocalFuture<T, F>`

`impl<T, F> Sync for TaskLocalFuture<T, F>`

`impl<T, F> UnsafeUnpin for TaskLocalFuture<T, F>`

`impl<T, F> UnwindSafe for TaskLocalFuture<T, F>`

`impl<T, U> Into for TaskLocalFuture<T, F>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for TaskLocalFuture<T, F>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for TaskLocalFuture<T, F>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

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

fn drop(self: &mut Self)

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

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