Struct WorkerContext 

pub struct WorkerContext { /* private fields */ }

Shared context for stateful workers with in-memory key-value store.

Provides a process-local, concurrency-safe storage for workers to share state. The store is backed by DashMap for lock-free concurrent access.

Performance

• Uses DashMap for lock-free concurrent operations
• Cloning is cheap (only clones the Arc, not the data)

Implementations

impl WorkerContext

pub fn new() -> Self

Creates a new empty WorkerContext.

pub fn get(&self, key: &str) -> Option<Value>

Gets a value from the store by key.

Returns None if the key doesn’t exist.

Note: This method clones the value. For read-heavy workloads, consider caching values or using primitives that are cheap to clone.

pub fn with_value<F, R>(&self, key: &str, f: F) -> R

where F: FnOnce(Option<&Value>) -> R,

Gets a value and applies a function to it without cloning.

This is more efficient than get() when you only need to inspect the value.

Examples

let ctx = WorkerContext::new();
ctx.set("count", serde_json::json!(42));
let is_positive = ctx.with_value("count", |v| {
    v.and_then(|val| val.as_i64()).map(|n| n > 0).unwrap_or(false)
});
assert!(is_positive);

pub fn set(&self, key: impl Into<String>, value: Value)

Sets a value in the store.

pub fn delete(&self, key: &str) -> Option<Value>

Deletes a key from the store.

Returns the previous value if it existed.

pub fn len(&self) -> usize

Returns the number of key-value pairs in the store.

pub fn is_empty(&self) -> bool

Returns true if the store contains no key-value pairs.

pub fn contains_key(&self, key: &str) -> bool

Checks if a key exists in the store without retrieving the value.

pub fn update<F>(&self, key: &str, f: F)

where F: FnOnce(Option<Value>) -> Option<Value>,

Updates a value in the store using a function.

The function receives the current value (or None if the key doesn’t exist) and returns an Option to control the update:

• Some(value) - Insert or update the key with the new value
• None - Remove the key from the store (if it existed)

Warning

Returning None from the update function will delete the key from the store. This is useful for conditional removal but can lead to unexpected data loss if not intended.

Examples

let ctx = WorkerContext::new();

// Increment a counter, initializing to 1 if it doesn't exist
ctx.update("counter", |v| {
    let count = v.and_then(|v| v.as_u64()).unwrap_or(0);
    Some(serde_json::json!(count + 1))
});
assert_eq!(ctx.get("counter").and_then(|v| v.as_u64()), Some(1));

// Conditionally remove a key by returning None
ctx.set("temp", serde_json::json!("remove me"));
ctx.update("temp", |_| None); // Key is now deleted
assert!(!ctx.contains_key("temp"));

Trait Implementations

impl Clone for WorkerContext

fn clone(&self) -> WorkerContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WorkerContext

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

Formats the value using the given formatter.

impl Default for WorkerContext

fn default() -> Self

Returns the “default value” for a type.