Struct Context

pub struct Context<T: Sync + 'static>(/* private fields */);

A wrapper type used for creating pointers to thread-locals

Implementations

impl<T> Context<T>

where T: Sync,

pub fn new(inner: T) -> Context<T>

Create a new thread-local context

If the compat feature flag is enabled, Context will downgrade to internally using std::sync::Arc to ensure the validity of T

Usage

Either wrap a type with Context and assign to a thread-local, or use as an unwrapped field in a struct that derives AsContext

Example

use std::sync::atomic::{AtomicUsize, Ordering};

use async_local::{AsyncLocal, Context};
use generativity::make_guard;

thread_local! {
  static COUNTER: Context<AtomicUsize> = Context::new(AtomicUsize::new(0));
}

#[async_local::main(flavor = "current_thread")]
async fn main() {
  make_guard!(guard);
  let counter = COUNTER.local_ref(guard);

  let _count = counter
    .with_blocking(|counter| counter.fetch_add(1, Ordering::Relaxed))
    .await
    .unwrap();
}

pub unsafe fn local_ref<'a>(&self) -> LocalRef<'a, T>

Construct LocalRef with an unbounded lifetime.

Safety

This lifetime must be restricted to avoid unsoundness

Trait Implementations

impl<T> AsContext for Context<T>

where T: Sync,

type Target = T

impl<T> AsRef<Context<T>> for Context<T>

where T: Sync,

fn as_ref(&self) -> &Context<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Deref for Context<T>

where T: Sync,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.