Struct 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

# 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> where T: 'static,

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));
# }

Trait Implementations

impl<'__pin, T, F> Unpin for TaskLocalFuture<T, F> where PinnedFieldsOf<__Origin<'__pin, T, F>>: Unpin, T: 'static,

impl<T, F> Debug for TaskLocalFuture<T, F> where T: Debug + 'static,

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

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

fn drop(&mut self)

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

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

Auto Trait Implementations

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

impl<T, F> Freeze for TaskLocalFuture<T, F> where &'static LocalKey<T>: Freeze, Option<T>: Freeze, Option<F>: Freeze,

impl<T, F> RefUnwindSafe for TaskLocalFuture<T, F> where &'static LocalKey<T>: RefUnwindSafe, Option<T>: RefUnwindSafe, Option<F>: RefUnwindSafe,

impl<T, F> Send for TaskLocalFuture<T, F> where &'static LocalKey<T>: Send, Option<T>: Send, Option<F>: Send,

impl<T, F> Sync for TaskLocalFuture<T, F> where &'static LocalKey<T>: Sync, Option<T>: Sync, Option<F>: Sync,

impl<T, F> UnwindSafe for TaskLocalFuture<T, F> where &'static LocalKey<T>: UnwindSafe, Option<T>: UnwindSafe, Option<F>: UnwindSafe,

Blanket Implementations

impl<F> IntoFuture for TaskLocalFuture<T, F> where F: Future,

type Output = <F as Future>::Output;
type IntoFuture = F;
fn into_future(self) -> <F as IntoFuture>::IntoFuture

impl<T> Any for TaskLocalFuture<T, F> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for TaskLocalFuture<T, F> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for TaskLocalFuture<T, F> where T: ?Sized,

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

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

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for TaskLocalFuture<T, F> where U: From<T>,

fn into(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<U> for TaskLocalFuture<T, F> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for TaskLocalFuture<T, F> where U: TryFrom<T>,

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