Struct ReactiveCell 

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

A reactive value you can read, write and subscribe to, with the primitive behind it erased - along with its type parameters, so fields, map entries and in-memory values share one type and one collection.

Writes always reach where the value lives.

Implementations

impl<T> ReactiveCell<T>

where T: Clone + Send + Sync + 'static,

pub fn new(initial: T) -> Self

An in-memory cell, for reactive values that are not persisted.

pub fn get(&self) -> T

pub fn durable(&self) -> Durable<'_, Self>

The same writes, each returning only once the value is on disk.

A cell over a value held in memory has nothing to commit to, and its writes here behave as the plain ones do.

pub fn set(&self, value: T) -> WriteResult<()>

Fails if the write is refused - by an interceptor, or by the store. The cache is left to the store subscription, so a refused write never shows up in get().

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

where F: FnOnce(T) -> T,

Read-modify-write, not atomic.

pub fn modify<F>(&self, f: F) -> WriteResult<()>

where F: FnOnce(&mut T),

Same caveat as ReactiveCell::update: read-modify-write, not atomic.

pub fn subscribe<F>(&self, callback: F) -> SignalSubscription

where F: Fn(&T) + Send + Sync + 'static,

pub fn subscribe_with_source<F>(&self, callback: F) -> SignalSubscription

where F: Fn(&T, Option<Uuid>) + Send + Sync + 'static,

Subscribes with the provenance of each change, so a subscriber can tell its own writes from everyone else’s.

pub fn subscription_with(&self) -> Watch<Self, Immediate>

Configures a subscription: filtering, provenance, and where the callback runs. See Watch.

Trait Implementations

impl<T> Clone for ReactiveCell<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 + Clone + Send + Sync + 'static> Debug for ReactiveCell<T>

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

Formats the value using the given formatter.

impl<T> Reactive<T> for ReactiveCell<T>

where T: Clone + Send + Sync + 'static,

fn get(&self) -> T

fn subscribe_with_source<F>(&self, callback: F) -> SignalSubscription

where F: for<'a> Fn(&'a T, Option<Uuid>) + Send + Sync + 'static,

fn keepalive(&self) -> Option<Arc<dyn Send + Sync>>

fn subscribe<F>(&self, callback: F) -> SignalSubscription

where F: for<'a> Fn(&'a T) + Send + Sync + 'static,

impl<T> Watchable for ReactiveCell<T>

where T: Clone + Send + Sync + 'static,

type Item = T

What a subscriber is handed.

fn watch_id(&self) -> Uuid

Identity of the handle, so external can tell its own writes apart.

fn watch_raw<F>(&self, callback: F) -> SignalSubscription

where F: Fn(&T, Option<Uuid>) + Send + Sync + 'static,

fn filterable(_item: &Self::Item) -> bool

Whether Watch::external may drop this item when it came from this handle.