Struct yrs::atomic::AtomicRef

pub struct AtomicRef<T>(/* private fields */);

Atomic reference holding a value, that’s supposed to be shared - potentially between multiple threads. Internally this value is hidden behind Arc reference, which is returned during AtomicRef::get method. This cell doesn’t allow to return &mut references to stored object. Instead updates can be performed as lock-free operation mutating function passed over during AtomicRef::update call.

Example:

use yrs::atomic::AtomicRef;

let atom = AtomicRef::new(vec!["John"]);
atom.update(|users| {
    let mut users_copy = users.cloned().unwrap_or_else(Vec::default);
    users_copy.push("Susan");
    users_copy
});
let users = atom.get(); // John, Susan

Important note: since AtomicRef::update may call provided function multiple times (in scenarios, when another thread intercepted update with its own update call), provided function should be idempotent and preferably quick to execute.

Implementations

impl<T> AtomicRef<T>

pub fn new(value: T) -> Self

Creates a new instance of AtomicRef. This call boxes provided value and allocates it on a heap.

pub fn get(&self) -> Option<Arc<T>>

Returns a reference to current state hold by the AtomicRef. Keep in mind that after acquiring it, it may not present the current view of the state, but instead be changed by the concurrent AtomicRef::update call.

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

Atomically replaces currently stored value with a new one, returning the last stored value.

pub fn take(&self) -> Option<Arc<T>>

Atomically replaces currently stored value with a null, returning the last stored value.

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

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

Updates stored value in place using provided function f, which takes read-only refrence to the most recently known state and producing new state in the result.

Important note: since AtomicRef::update may call provided function multiple times (in scenarios, when another thread intercepted update with its own update call), provided function should be idempotent and preferably quick to execute.

impl<T: Copy> AtomicRef<T>

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

Returns a current state copy hold by the AtomicRef. Keep in mind that after acquiring it, it may not present the current view of the state, but instead be changed by the concurrent AtomicRef::update call.

Trait Implementations

impl<T: Debug> Debug for AtomicRef<T>

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

Formats the value using the given formatter.

impl<T> Default for AtomicRef<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for AtomicRef<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> PartialEq for AtomicRef<T>

where T: PartialEq,

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Eq for AtomicRef<T>

where T: Eq,

impl<T> Send for AtomicRef<T>

impl<T> Sync for AtomicRef<T>