Struct leptos::StoredValue

pub struct StoredValue<T>
where
    T: 'static,
{ /* private fields */ }

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>

pub fn get_value(&self) -> T

where T: Clone,

Returns a clone of the current stored value.

Panics

Panics if you try to access a value owned by a reactive node that has been disposed.

Examples

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

// calling .get_value() clones and returns the value
assert_eq!(data.get_value().value, "a");
// can be `data().value` on nightly
// assert_eq!(data().value, "a");

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

where T: Clone,

Same as StoredValue::get_value but will not panic by default.

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

Applies a function to the current stored value and returns the result.

Panics

Panics if you try to access a value owned by a reactive node that has been disposed.

Examples

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

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

pub fn try_with_value<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Same as StoredValue::with_value but returns [Some(O)] only if the stored value has not yet been disposed. None otherwise.

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

Updates the stored value.

Examples

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

use leptos_reactive::*;

pub struct MyUncloneableData {
    pub value: String,
}

let data = store_value(MyUncloneableData { value: "a".into() });
let updated = data.try_update_value(|data| {
    data.value = "b".into();
    data.value.clone()
});

assert_eq!(data.with_value(|data| data.value.clone()), "b");
assert_eq!(updated, Some(String::from("b")));

Panics

Panics if there is no current reactive runtime, or if the stored value has been disposed.

pub fn try_update_value<O>(self, f: impl FnOnce(&mut T) -> O) -> Option<O>

Same as Self::update_value, but returns [Some(O)] if the stored value has not yet been disposed, None otherwise.

pub fn dispose(self)

Disposes of the stored value

pub fn set_value(&self, value: T)

Sets the stored value.

Examples

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

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

Same as Self::set_value, but returns None if the stored value has not yet been disposed, [Some(T)] otherwise.

impl<T> StoredValue<T>

pub fn new(value: T) -> StoredValue<T>

Creates a non-reactive wrapper 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.

// this structure is neither `Copy` nor `Clone`
pub struct MyUncloneableData {
  pub value: String
}

// ❌ this won't compile, as it can't be cloned or copied into the closures
let data = MyUncloneableData { value: "a".into() };
let callback_a = move || data.value == "a";
let callback_b = move || data.value == "b";

// this structure is neither `Copy` nor `Clone`
pub struct MyUncloneableData {
    pub value: String,
}

// ✅ you can move the `StoredValue` and access it with .with_value()
let data = StoredValue::new(MyUncloneableData { value: "a".into() });
let callback_a = move || data.with_value(|data| data.value == "a");
let callback_b = move || data.with_value(|data| data.value == "b");

Panics

Panics if there is no current reactive runtime.

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>

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

Formats the value using the given formatter.

impl<T> Default for StoredValue<T>

where T: Default,

fn default() -> StoredValue<T>

Returns the “default value” for a type.

impl<T> Hash for StoredValue<T>

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 for StoredValue<T>

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>