Trait AsyncLocal

pub trait AsyncLocal<T>
where
    T: AsContext,
{
    // Required methods
    fn with_blocking<F, R>(&'static self, f: F) -> JoinHandle<R>
       where F: for<'id> FnOnce(LocalRef<'id, T::Target>) -> R + Send + 'static,
             R: Send + 'static;
    fn with_async<F, R>(&'static self, f: F) -> impl Future<Output = R>
       where F: for<'a> AsyncFnMut(LocalRef<'a, T::Target>) -> R;
    fn local_ref<'id>(
        &'static self,
        guard: Guard<'id>,
    ) -> LocalRef<'id, T::Target>;
}

LocalKey extension for creating thread-safe pointers to thread-local Context

Required Methods

fn with_blocking<F, R>(&'static self, f: F) -> JoinHandle<R>

where F: for<'id> FnOnce(LocalRef<'id, T::Target>) -> R + Send + 'static, R: Send + 'static,

Available on crate features tokio-runtime or barrier-protected-runtime only.

A wrapper around tokio::task::spawn_blocking that safely constrains the lifetime of LocalRef

fn with_async<F, R>(&'static self, f: F) -> impl Future<Output = R>

where F: for<'a> AsyncFnMut(LocalRef<'a, T::Target>) -> R,

Acquire a reference to the value in this TLS key.

fn local_ref<'id>(&'static self, guard: Guard<'id>) -> LocalRef<'id, T::Target>

Create a pointer to a thread local Context using a trusted lifetime carrier.

Usage

Use generativity::make_guard to generate a unique invariant lifetime brand

Safety

When barrier-protected-runtime is enabled, tokio::main and tokio::test must be used with crate = "async_local" set to configure the runtime to synchronize shutdown. This ensures the validity of all invariant lifetimes

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T> AsyncLocal<T> for LocalKey<T>

where T: AsContext,

fn with_blocking<F, R>(&'static self, f: F) -> JoinHandle<R>

where F: for<'id> FnOnce(LocalRef<'id, T::Target>) -> R + Send + 'static, R: Send + 'static,

Available on crate features tokio-runtime or barrier-protected-runtime only.

async fn with_async<F, R>(&'static self, f: F) -> R

where F: for<'a> AsyncFnMut(LocalRef<'a, T::Target>) -> R,

fn local_ref<'id>(&'static self, guard: Guard<'id>) -> LocalRef<'id, T::Target>

Implementors