Struct wrrm::Wrrm

pub struct Wrrm<T> { /* fields omitted */ }

"Write-rarely-read-many" wrapper.

This lock-free container is suitable in situations where you perform a lot of reads to a T, but only rarely modify that T.

From a logic point of view, it is more or less the equivalent of an RwLock, except that:

• It works in no_std platforms.
• Reading the T always takes the same time and will never wait for a lock to be released.
• Writing the T is done in a compare-and-swap way, and updates might have to be performed multiple times.

Implementation details

This container contains more or less the equivalent of an Atomic<Arc<T>>. Accessing T is quite cheap, as it only consists in cloning the Arc. Modifying T can be done by performing a deep clone of T, then storing a pointer to the updated version in the Atomic.

If N threads try to update the T at the same time, the entire update of T might need to be performed more than N times. For example, if two threads try to update T at the same time, one of them will win and perform the update. When trying to apply its own update, the other thread will detect that the T has been touched in-between and will restart its own update from scratch.

Implementations

impl<T> Wrrm<T>

pub fn new(value: T) -> Self

Creates a new Wrrm.

pub fn access(&self) -> Access<T>

Grants shared access to the content.

This Access struct will always point to the same, potentially stale, version. In other words, if the content of the Wrrm is updated while an Access is alive, this Access will still point to the old version.

pub fn modify_with(&self, modification: impl FnMut(&mut T)) where
    T: Clone, 

Modifies the value using the given function.

Important: The function might be called multiple times.

Trait Implementations

impl<T> Debug for Wrrm<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T: Default> Default for Wrrm<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T> From<T> for Wrrm<T>

fn from(value: T) -> Self

Performs the conversion.