Struct ActorLocal 

pub struct ActorLocal<T: Send + 'static> { /* private fields */ }

Per-actor local storage slot.

Declare as a static and access from handler methods via the context:

use hyperactor::actor_local::Entry;

static MY_LOCAL: ActorLocal<MyType> = ActorLocal::new();

fn handle(&mut self, cx: &Context<Self>, msg: MyMessage) {
    // Get an entry (holds the lock)
    let mut entry = MY_LOCAL.entry(cx);

    // Use fluent API
    *MY_LOCAL.entry(cx).or_default().get_mut() += 1;

    // Or pattern match
    match MY_LOCAL.entry(cx) {
        Entry::Occupied(mut o) => {
            let value = o.get_mut();
            // modify value...
        }
        Entry::Vacant(v) => {
            v.insert(initial_value);
        }
    }
}

Each ActorLocal has its own internal lock, so accessing multiple ActorLocal statics simultaneously is safe and will not deadlock.

Implementations

impl<T: Send + 'static> ActorLocal<T>

pub const fn new() -> Self

Create a new actor-local storage slot.

pub fn entry<'a, Cx: Actor>(&'a self, cx: &'a Cx) -> Entry<'a, T>

Get an entry into actor-local storage.

The returned Entry holds the lock until dropped, allowing mutable access without requiring Clone.

Trait Implementations

impl<T: Send + 'static> Clone for ActorLocal<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Send + 'static> Default for ActorLocal<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Send + 'static> Send for ActorLocal<T>

impl<T: Send + 'static> Sync for ActorLocal<T>