Struct refreshable::Refreshable

pub struct Refreshable<T, E> { /* fields omitted */ }

A wrapper around a live-refreshable value.

Implementations

impl<T, E> Refreshable<T, E> where
    T: PartialEq + 'static + Sync + Send,
    E: 'static, 

pub fn new(value: T) -> (Refreshable<T, E>, RefreshHandle<T, E>)

Creates a new Refreshable with an initial value, returning it along with a RefreshHandle used to update it with new values.

pub fn get(&self) -> Guard<'_, T>

Returns a guard type providing access to a snapshot of the refreshable's current value.

pub fn subscribe<F>(&self, callback: F) -> Result<Subscription<T, E>, E> where
    F: Fn(&T) -> Result<(), E> + 'static + Sync + Send, 

Subscribes to the refreshable.

The callback will be invoked every time the refreshable's value changes, and is also called synchronously when this method is called with the current value. If the callback returns Ok, a Subscription object is returned that will unsubscribe from the refreshable when it drops. If the callback returns Err, this method will return the error and the callback will not be invoked on updates to the value.

pub fn subscribe_ok<F>(&self, callback: F) -> Subscription<T, E> where
    F: Fn(&T) + 'static + Sync + Send, 

Subscribes to the refreshable with an infallible callback.

This is a convenience method to simplify subscription when the callback can never fail.

pub fn map<F, R>(&self, map: F) -> Refreshable<R, E> where
    F: Fn(&T) -> R + 'static + Sync + Send,
    R: PartialEq + 'static + Sync + Send, 

Creates a new refreshable from this one by applying a mapping function to the value.

This can be used to narrow the scope of the refreshable value. Updates to the initial refreshable value will propagate to the mapped refreshable value, but the mapped refreshable's subscriptions will only be invoked if the mapped value actually changed.