Struct UsePersistent 

pub struct UsePersistent<T: Serialize + DeserializeOwned + Default + 'static> { /* private fields */ }

Storage that persists across application reloads

Implementations

impl<T: Serialize + DeserializeOwned + Default + 'static> UsePersistent<T>

pub fn read(&self) -> StorageRef<'_, T>

Returns a reference to the value

pub fn write(&self) -> StorageRefMut<'_, T>

Returns a mutable reference to the value

pub fn set(&self, value: T)

Sets the value

pub fn modify<F: FnOnce(&mut T)>(&self, f: F)

Modifies the value

impl<T: Serialize + DeserializeOwned + Default + Clone + 'static> UsePersistent<T>

pub fn get(&self) -> T

Returns a clone of the value

Methods from Deref<Target = UseRef<StorageEntry<ClientStorage, T>>>

pub fn read(&self) -> Ref<'_, T>

Read the value in the RefCell into a Ref. If this method is called while other values are still being read or write, then your app will crash.

Be very careful when working with this method. If you can, consider using the with and with_mut methods instead, choosing to render Elements during the read calls.

pub fn write(&self) -> RefMut<'_, T>

Mutably unlock the value in the RefCell. This will mark the component as “dirty”

Uses to write should be as short as possible.

Be very careful when working with this method. If you can, consider using the with and with_mut methods instead, choosing to render Elements during the read and write calls.

pub fn set(&self, new: T)

Set the curernt value to new_value. This will mark the component as “dirty”

This change will propagate immediately, so any other contexts that are using this RefCell will also be affected. If called during an async context, the component will not be re-rendered until the next .await call.

pub fn write_silent(&self) -> RefMut<'_, T>

Mutably unlock the value in the RefCell. This will not mark the component as dirty. This is useful if you want to do some work without causing the component to re-render.

Uses to write should be as short as possible.

Be very careful when working with this method. If you can, consider using the with and with_mut methods instead, choosing to render Elements

pub fn with<O>(&self, immutable_callback: impl FnOnce(&T) -> O) -> O

Take a reference to the inner value termporarily and produce a new value

Note: You can always “reborrow” the value through the RefCell. This method just does it for you automatically.

let val = use_ref(|| HashMap::<u32, String>::new());


// use reborrowing
let inner = &*val.read();

// or, be safer and use `with`
val.with(|i| println!("{:?}", i));

pub fn with_mut<O>(&self, mutable_callback: impl FnOnce(&mut T) -> O) -> O

Take a reference to the inner value termporarily and produce a new value, modifying the original in place.

Note: You can always “reborrow” the value through the RefCell. This method just does it for you automatically.

let val = use_ref(|| HashMap::<u32, String>::new());


// use reborrowing
let inner = &mut *val.write();

// or, be safer and use `with`
val.with_mut(|i| i.insert(1, "hi"));

pub fn needs_update(&self)

Call the inner callback to mark the originator component as dirty.

This will cause the component to be re-rendered after the current scope has ended or the current async task has been yielded through await.

Trait Implementations

impl<T: Serialize + DeserializeOwned + Default + 'static> Deref for UsePersistent<T>

type Target = UseRef<StorageEntry<ClientStorage, T>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Serialize + DeserializeOwned + Default + 'static> DerefMut for UsePersistent<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.