Struct fermi::hooks::AtomState

pub struct AtomState<V: 'static> { /* private fields */ }

Implementations

impl<T: 'static> AtomState<T>

pub fn set(&self, new: T)

Set the state to a new value.

pub fn current(&self) -> Rc<T>

Get the current value of the state by cloning its container Rc.

This is useful when you are dealing with state in async contexts but need to know the current value. You are not given a reference to the state.

Examples

An async context might need to know the current value:

fn component(cx: Scope) -> Element {
    let count = use_state(cx, || 0);
    cx.spawn({
        let set_count = count.to_owned();
        async move {
            let current = set_count.current();
        }
    })
}

pub fn setter(&self) -> Rc<dyn Fn(T)>

Get the setter function directly without the AtomState wrapper.

This is useful for passing the setter function to other components.

However, for most cases, calling to_owned on the state is the preferred way to get “another” state handle.

Examples

A component might require an Rc<dyn Fn(T)> as an input to set a value.

fn component(cx: Scope) -> Element {
    let value = use_state(cx, || 0);

    rsx!{
        Component {
            handler: value.setter()
        }
    }
}

pub fn modify(&self, f: impl FnOnce(&T) -> T)

Set the state to a new value, using the current state value as a reference.

This is similar to passing a closure to React’s set_value function.

Examples

Basic usage:

fn component(cx: Scope) -> Element {
    let value = use_state(cx, || 0);

    // to increment the value
    value.modify(|v| v + 1);

    // usage in async
    cx.spawn({
        let value = value.to_owned();
        async move {
            value.modify(|v| v + 1);
        }
    });

}

pub fn get(&self) -> &T

Get the value of the state when this handle was created.

This method is useful when you want an Rc around the data to cheaply pass it around your app.

Warning

This will return a stale value if used within async contexts.

Try current to get the real current value of the state.

Example

fn component(cx: Scope) -> Element {
    let value = use_state(cx, || 0);

    let as_rc = value.get();
    assert_eq!(as_rc.as_ref(), &0);

}

pub fn get_rc(&self) -> &Rc<T>

pub fn needs_update(&self)

Mark all consumers of this atom to re-render

fn component(cx: Scope) -> Element {
    let count = use_state(cx, || 0);
    cx.spawn({
        let count = count.to_owned();
        async move {
            // for the component to re-render
            count.needs_update();
        }
    })
}

impl<T: Clone> AtomState<T>

pub fn with_mut(&self, apply: impl FnOnce(&mut T))

Get a mutable handle to the value by calling ToOwned::to_owned on the current value.

This is essentially cloning the underlying value and then setting it, giving you a mutable handle in the process. This method is intended for types that are cheaply cloneable.

If you are comfortable dealing with RefMut, then you can use make_mut to get the underlying slot. However, be careful with RefMut since you might panic if the RefCell is left open.

Examples

let val = use_state(cx, || 0);

val.with_mut(|v| *v = 1);

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

Get a mutable handle to the value by calling ToOwned::to_owned on the current value.

This is essentially cloning the underlying value and then setting it, giving you a mutable handle in the process. This method is intended for types that are cheaply cloneable.

Warning

Be careful with RefMut since you might panic if the RefCell is left open!

Examples

let val = use_state(cx, || 0);

*val.make_mut() += 1;

pub fn split(&self) -> (&T, &Self)

Convert this handle to a tuple of the value and the handle itself.

Trait Implementations

impl<T: Add + Copy> Add<T> for &AtomState<T>

type Output = <T as Add>::Output

The resulting type after applying the + operator.

fn add(self, other: T) -> Self::Output

Performs the + operation.

impl<T: Add<Output = T> + Copy> AddAssign<T> for &AtomState<T>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: Add<Output = T> + Copy> AddAssign<T> for AtomState<T>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: Binary> Binary for AtomState<T>

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

Formats the value using the given formatter.

impl<T: 'static> Clone for AtomState<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AtomState<T>

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

Formats the value using the given formatter.

impl<T> Deref for AtomState<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: 'static + Display> Display for AtomState<T>

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

Formats the value using the given formatter.

impl<T: Div + Copy> Div<T> for &AtomState<T>

type Output = <T as Div>::Output

The resulting type after applying the / operator.

fn div(self, other: T) -> Self::Output

Performs the / operation.

impl<T: Div<Output = T> + Copy> DivAssign<T> for &AtomState<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Div<Output = T> + Copy> DivAssign<T> for AtomState<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<V> Drop for AtomState<V>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Mul + Copy> Mul<T> for &AtomState<T>

type Output = <T as Mul>::Output

The resulting type after applying the * operator.

fn mul(self, other: T) -> Self::Output

Performs the * operation.

impl<T: Mul<Output = T> + Copy> MulAssign<T> for &AtomState<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Mul<Output = T> + Copy> MulAssign<T> for AtomState<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Not + Copy> Not for &AtomState<T>

type Output = <T as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: Not + Copy> Not for AtomState<T>

type Output = <T as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: PartialEq> PartialEq<T> for AtomState<T>

fn eq(&self, other: &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 PartialEq<bool> for &AtomState<bool>

fn eq(&self, other: &bool) -> 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: PartialEq> PartialEq for AtomState<T>

fn eq(&self, other: &AtomState<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: Sub + Copy> Sub<T> for &AtomState<T>

type Output = <T as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, other: T) -> Self::Output

Performs the - operation.

impl<T: Sub<Output = T> + Copy> SubAssign<T> for &AtomState<T>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: Sub<Output = T> + Copy> SubAssign<T> for AtomState<T>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.