Struct SharedContainer 

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

👎Deprecated since 0.3.0: Use Shared<T> for sync or AsyncShared<T> for async instead. See migration guide in docs.

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

DEPRECATED: Use Shared<T> for synchronous code or AsyncShared<T> (with async feature) for asynchronous code instead.

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)

Migration Guide

// Old (2.x with std-sync)
// use shared_container::SharedContainer;
// let container = SharedContainer::new(42);

// New (0.3)
use shared_container::{Shared, SyncAccess};
let container = Shared::new(42);

For async code with tokio:

// Old (2.x with tokio-sync)
// use shared_container::SharedContainer;
// let container = SharedContainer::new(42);

// New (0.3)
use shared_container::{AsyncShared, AsyncAccess};
let container = AsyncShared::new(42);

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. WARNING: This method uses blocking operations when using tokio-sync feature, which is not 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. WARNING: This method always returns None when using tokio-sync feature. Use read_async() instead.

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. WARNING: This method always returns None when using tokio-sync feature. Use write_async() instead.

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>

Available on crate features std-sync or tokio-sync only.

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

Available on crate features std-sync or tokio-sync only.