Struct leptos::StoredValue

pub struct StoredValue<T>(_)
where
    T: 'static;

A non-reactive wrapper for any value, which can be created with store_value.

If you want a reactive wrapper, use create_signal.

This allows you to create a stable reference for any value by storing it within the reactive system. Like the signal types (e.g., ReadSignal and RwSignal), it is Copy and 'static. Unlike the signal types, it is not reactive; accessing it does not cause effects to subscribe, and updating it does not notify anything else.

Implementations

impl<T> StoredValue<T>where
    T: 'static,

pub fn get(&self) -> Twhere
    T: Clone,

Clones and returns the current stored value.

If you want to get the value without cloning it, use StoredValue::with. (value.get() is equivalent to value.with(T::clone).)

#[derive(Clone)]
pub struct MyCloneableData {
  pub value: String
}
let data = store_value(cx, MyCloneableData { value: "a".into() });

// calling .get() clones and returns the value
assert_eq!(data.get().value, "a");
// there's a short-hand getter form
assert_eq!(data().value, "a");
});

pub fn with<U>(&self, f: impl FnOnce(&T) -> U) -> U

Applies a function to the current stored value.

pub struct MyUncloneableData {
  pub value: String
}
let data = store_value(cx, MyUncloneableData { value: "a".into() });

// calling .with() to extract the value
assert_eq!(data.with(|data| data.value.clone()), "a");
});

pub fn update(&self, f: impl FnOnce(&mut T))

Applies a function to the current value to mutate it in place.

pub struct MyUncloneableData {
  pub value: String
}
let data = store_value(cx, MyUncloneableData { value: "a".into() });
data.update(|data| data.value = "b".into());
assert_eq!(data.with(|data| data.value.clone()), "b");
});

pub fn set(&self, value: T)

Sets the stored value.

pub struct MyUncloneableData {
  pub value: String
}
let data = store_value(cx, MyUncloneableData { value: "a".into() });
data.set(MyUncloneableData { value: "b".into() });
assert_eq!(data.with(|data| data.value.clone()), "b");
});

Trait Implementations

impl<T> Clone for StoredValue<T>

fn clone(&self) -> StoredValue<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for StoredValue<T>where
    T: Debug + 'static,

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

Formats the value using the given formatter.

impl<T> Fn() for StoredValue<T>where
    T: Clone,

extern "rust-call" fn call(
    &self,
    _args: ()
) -> <StoredValue<T> as FnOnce()>::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T> FnMut() for StoredValue<T>where
    T: Clone,

extern "rust-call" fn call_mut(
    &mut self,
    _args: ()
) -> <StoredValue<T> as FnOnce()>::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T> FnOnce() for StoredValue<T>where
    T: Clone,

type Output = T

The returned type after the call operator is used.

extern "rust-call" fn call_once(
    self,
    _args: ()
) -> <StoredValue<T> as FnOnce()>::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T> Hash for StoredValue<T>where
    T: Hash + 'static,

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq<StoredValue<T>> for StoredValue<T>where
    T: PartialEq<T> + 'static,

fn eq(&self, other: &StoredValue<T>) -> 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> Copy for StoredValue<T>

impl<T> Eq for StoredValue<T>where
    T: Eq + 'static,

impl<T> StructuralEq for StoredValue<T>where
    T: 'static,

impl<T> StructuralPartialEq for StoredValue<T>where
    T: 'static,