Struct AtomicValue 

pub struct AtomicValue<T> { /* private fields */ }

A concurrent-safe single value container using arc-swap.

This container provides atomic load and store operations for a single value. It’s ideal for configuration values or shared state that needs to be read frequently and updated occasionally.

Type Parameters

• T - The value type

Example

use litellm_rs::utils::sync::AtomicValue;

let value: AtomicValue<String> = AtomicValue::new("initial".to_string());
assert_eq!(value.load().as_ref(), "initial");

value.store("updated".to_string());
assert_eq!(value.load().as_ref(), "updated");

Implementations

impl<T> AtomicValue<T>

pub fn new(value: T) -> Self

Creates a new AtomicValue with the specified initial value.

Arguments

• value - The initial value

Example

use litellm_rs::utils::sync::AtomicValue;

let value: AtomicValue<i32> = AtomicValue::new(42);

pub fn load(&self) -> Arc<T>

Loads the current value.

Returns an Arc pointing to the current value. This is a very fast operation and does not block other readers or writers.

Returns

An Arc<T> containing the current value.

Example

use litellm_rs::utils::sync::AtomicValue;

let value: AtomicValue<i32> = AtomicValue::new(42);
let current = value.load();
assert_eq!(*current, 42);

pub fn store(&self, value: T)

Stores a new value, replacing the current one.

This operation is atomic and will not block readers.

Arguments

• value - The new value to store

Example

use litellm_rs::utils::sync::AtomicValue;

let value: AtomicValue<i32> = AtomicValue::new(42);
value.store(100);
assert_eq!(*value.load(), 100);

pub fn swap(&self, value: T) -> Arc<T>

Swaps the current value with a new one, returning the old value.

Arguments

• value - The new value to store

Returns

An Arc<T> containing the previous value.

Example

use litellm_rs::utils::sync::AtomicValue;

let value: AtomicValue<i32> = AtomicValue::new(42);
let old = value.swap(100);
assert_eq!(*old, 42);
assert_eq!(*value.load(), 100);

pub fn store_arc(&self, value: Arc<T>)

Stores a new value from an Arc.

This is useful when you already have an Arc and want to avoid an extra allocation.

Arguments

• value - An Arc containing the new value

Example

use litellm_rs::utils::sync::AtomicValue;
use std::sync::Arc;

let value: AtomicValue<i32> = AtomicValue::new(42);
value.store_arc(Arc::new(100));
assert_eq!(*value.load(), 100);

pub fn swap_arc(&self, value: Arc<T>) -> Arc<T>

Swaps the current value with a new Arc, returning the old value.

Arguments

• value - An Arc containing the new value

Returns

An Arc<T> containing the previous value.

Example

use litellm_rs::utils::sync::AtomicValue;
use std::sync::Arc;

let value: AtomicValue<i32> = AtomicValue::new(42);
let old = value.swap_arc(Arc::new(100));
assert_eq!(*old, 42);

impl<T: Clone> AtomicValue<T>

pub fn update<F>(&self, f: F) -> T

where F: Fn(&T) -> T,

Updates the value using a closure, with atomic compare-and-swap retry.

This operation uses ArcSwap::rcu() to perform a read-copy-update loop, retrying until the compare-and-swap succeeds. The closure may be called more than once if concurrent updates occur, so it must be side-effect-free (i.e., Fn rather than FnOnce).

Arguments

• f - A closure that takes a reference to the current value and returns the new value

Returns

The new value after the update.

Example

use litellm_rs::utils::sync::AtomicValue;

let value: AtomicValue<i32> = AtomicValue::new(42);
let new_value = value.update(|v| v + 1);
assert_eq!(new_value, 43);

pub fn get(&self) -> T

Gets a clone of the current value.

This is a convenience method that loads the value and clones it.

Returns

A clone of the current value.

Example

use litellm_rs::utils::sync::AtomicValue;

let value: AtomicValue<String> = AtomicValue::new("hello".to_string());
let cloned: String = value.get();
assert_eq!(cloned, "hello");

Trait Implementations

impl<T> Clone for AtomicValue<T>

fn clone(&self) -> Self

Creates a new AtomicValue pointing to the same underlying data.

Note: This creates a new AtomicValue that shares the same Arc, but updates to one will not affect the other after the clone.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AtomicValue<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for AtomicValue<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<Arc<T>> for AtomicValue<T>

fn from(value: Arc<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for AtomicValue<T>

fn from(value: T) -> Self

Converts to this type from the input type.