Struct SharedContainer

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

A unified container for shared data that works in both multi-threaded and single-threaded environments.

This struct provides an abstraction over different container types:

• Arc<std::sync::RwLock<T>> (used in standard multi-threaded environments)
• Arc<tokio::sync::RwLock<T>> (used for async/await support)
• Rc<RefCell<T>> (used in single-threaded environments like WebAssembly)

It allows code to be written once but compile to the most efficient implementation based on the environment where it will run and the features enabled.

Implementations

impl<T: Clone> SharedContainer<T>

pub fn get_cloned(&self) -> Option<T>

Gets a clone of the contained value.

This method acquires a read lock, clones the value, and releases the lock.

Returns

• Some(T): A clone of the contained value
• None: If the lock couldn’t be acquired

Note

When using the tokio-sync feature, this method will try to acquire the lock in a blocking manner, which may not be ideal for async code. Consider using get_cloned_async() instead.

pub async fn get_cloned_async(&self) -> T

where T: Clone,

Available on crate feature tokio-sync only.

Gets a clone of the contained value asynchronously.

This method is only available when the tokio-sync feature is enabled.

Returns

A clone of the contained value

Examples

let container = SharedContainer::new(42);
let value = container.get_cloned_async().await;
assert_eq!(value, 42);

impl<T> SharedContainer<T>

pub fn new(value: T) -> Self

Creates a new SharedContainer containing the given value.

Parameters

• value: The value to store in the container

Returns

A new SharedContainer instance containing the value

pub fn read(&self) -> Option<SharedReadGuard<'_, T>>

Gets a read-only access guard to the contained value.

Returns

• Some(SharedReadGuard<T>): A guard allowing read-only access to the value
• None: If the lock couldn’t be acquired

Note

When using the tokio-sync feature, this method will always return None. Use read_async() instead for async access.

pub fn write(&self) -> Option<SharedWriteGuard<'_, T>>

Gets a writable access guard to the contained value.

Returns

• Some(SharedWriteGuard<T>): A guard allowing read-write access to the value
• None: If the lock couldn’t be acquired

Note

When using the tokio-sync feature, this method will always return None. Use write_async() instead for async access.

pub fn downgrade(&self) -> WeakSharedContainer<T>

Creates a weak reference to this container.

A weak reference doesn’t prevent the value from being dropped when no strong references remain, which helps break reference cycles that could cause memory leaks.

Returns

A WeakSharedContainer that points to the same data

pub async fn read_async(&self) -> SharedReadGuard<'_, T>

Available on crate feature tokio-sync only.

Asynchronously gets a read-only access guard to the contained value.

This method is only available when the tokio-sync feature is enabled.

Returns

A guard allowing read-only access to the value

Examples

let container = SharedContainer::new(42);
let guard = container.read_async().await;
assert_eq!(*guard, 42);

pub async fn write_async(&self) -> SharedWriteGuard<'_, T>

Available on crate feature tokio-sync only.

Asynchronously gets a writable access guard to the contained value.

This method is only available when the tokio-sync feature is enabled.

Returns

A guard allowing read-write access to the value

Examples

let container = SharedContainer::new(42);
let mut guard = container.write_async().await;
*guard = 100;

Trait Implementations

impl<T> Clone for SharedContainer<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: Debug> Debug for SharedContainer<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for SharedContainer<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Send> Send for SharedContainer<T>

impl<T: Send + Sync> Sync for SharedContainer<T>