Struct Synced 

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

Implementations

impl<T> Synced<T>

A thread-safe wrapper that provides synchronized access to an inner value.

Synced<T> wraps a value of type T in an Arc<Mutex<T>>, providing safe concurrent access across multiple threads.

pub fn with_lock<F, R>( &self, func: F, ) -> Result<R, PoisonError<MutexGuard<'_, T>>>

where F: FnOnce(&mut T) -> R,

Executes a function with exclusive access to the inner value.

This method acquires a lock on the internal mutex, passes a mutable reference to the inner value to the provided function, and returns the result.

Arguments

• func - A closure that takes a mutable reference to T and returns R

Returns

• Ok(R) - The result of the function if the lock was acquired successfully
• Err(PoisonError) - If the mutex was poisoned (a thread panicked while holding the lock)

Examples

use timsrust_utils::thread::Synced;

let synced = Synced::from(vec![1, 2, 3]);

let sum = synced.with_lock(|data| {
    data.iter().sum::<i32>()
}).unwrap();

assert_eq!(sum, 6);

pub fn try_finalize(self) -> Option<T>

Attempts to extract the inner value, consuming the Synced wrapper.

This method will only succeed if this is the last reference to the internal Arc and the mutex is not poisoned.

Returns

• Some(T) - The inner value if this was the last Arc reference and the mutex was not poisoned
• None - If there are other references to the Arc or the mutex was poisoned

Examples

use timsrust_utils::thread::Synced;

let synced = Synced::from(42);
let value = synced.try_finalize();

assert_eq!(value, Some(42));

use timsrust_utils::thread::Synced;

let synced = Synced::from(42);
let cloned = synced.clone();

// Cannot finalize because there are multiple references
let value = synced.try_finalize();
assert_eq!(value, None);

Trait Implementations

impl<T> Clone for Synced<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 Synced<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Synced<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<T> for Synced<T>

fn from(value: T) -> Self

Converts to this type from the input type.