Struct SnapshotState 

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

Cheap copyable mutable view of a state cell.

Ownership lives elsewhere: a composition slot, an OwnedMutableState, or the runtime for states created with mutableStateOf / MutableState::with_runtime.

Implementations

impl<T> MutableState<T>

where T: Clone + 'static,

pub fn with_runtime(value: T, runtime: RuntimeHandle) -> MutableState<T>

Creates a runtime-owned persistent state handle.

pub fn is_alive(&self) -> bool

Returns true if the underlying state cell is still alive (not released).

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

Like with, but returns None if the state cell has been released.

Use this in frame callbacks, fling animations, and other contexts where the owning composition group may have been disposed (e.g., tab switch).

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

Like value, but returns None if the state cell has been released.

pub fn as_state(&self) -> State<T>

pub fn try_retain(&self) -> Option<OwnedMutableState<T>>

Upgrades this handle into an owning state value if the cell is still alive.

pub fn retain(&self) -> OwnedMutableState<T>

Upgrades this handle into an owning state value.

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

pub fn update<R>(&self, f: impl FnOnce(&mut T) -> R) -> R

pub fn replace(&self, value: T)

Sets a new value, silently skipping the write if the state cell was released.

State cells can be released between when a SideEffect closure captures a MutableState handle and when the side effect actually runs (command application disposes composition groups, freeing their state slots, before side effects execute). Using with_typed_opt instead of with_typed avoids a panic on the stale handle.

pub fn set_value(&self, value: T)

pub fn set(&self, value: T)

pub fn value(&self) -> T

pub fn get(&self) -> T

pub fn get_non_reactive(&self) -> T

Gets the current value WITHOUT subscribing to recomposition.

Use this in layout/measure/draw phases to read state without causing the current composition scope to recompose when the state changes.

When to use

• In modifier nodes (like ScrollNode) during measure()
• In any layout phase code that reads state but shouldn’t trigger recomposition

When NOT to use

• In composable functions that should update when state changes
• When you want reactive UI updates

Trait Implementations

impl<T> Clone for MutableState<T>

where T: Clone + 'static,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MutableState<T>

where T: Debug + Clone + 'static,

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

Formats the value using the given formatter.

impl<T> PartialEq for MutableState<T>

where T: Clone + 'static,

fn eq(&self, other: &MutableState<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Copy for MutableState<T>

where T: Clone + 'static,

impl<T> Eq for MutableState<T>

where T: Clone + 'static,