Struct atomic_hooks::ReactiveStateAccess

pub struct ReactiveStateAccess<T, U, A> {
    pub id: StorageKey,
    pub _phantom_data_stored_type: PhantomData<T>,
    pub _phantom_data_undo: PhantomData<U>,
    pub _phantom_data_accessor_type: PhantomData<A>,
}

Accessor struct that provides access to getting and setting the state of the stored type

Fields

id: StorageKey

_phantom_data_stored_type: PhantomData<T>

_phantom_data_undo: PhantomData<U>

_phantom_data_accessor_type: PhantomData<A>

Implementations

impl<T, U, A> ReactiveStateAccess<T, U, A> where
    T: 'static, 

pub fn new(id: StorageKey) -> ReactiveStateAccess<T, U, A>

pub fn insert_set(self, value: T) where
    Self: OverloadedUpdateStateAccess<T>, 

pub fn set(self, value: T) where
    Self: OverloadedUpdateStateAccess<T>, 

pub fn remove(self) -> Option<T>

pub fn delete(self)

pub fn undo(&self) where
    Self: OverloadedUpdateStateAccess<T>, 

pub fn update<F: FnOnce(&mut T)>(&self, func: F) where
    Self: OverloadedUpdateStateAccess<T>, 

updates the stored state in place using the provided function

pub fn reset_to_default(&self) where
    Self: OverloadedUpdateStateAccess<T>, 

pub fn state_exists(self) -> bool

pub fn get_with<F: FnOnce(&T) -> R, R>(&self, func: F) -> R

pub fn on_update<F: FnOnce() -> R, R>(&self, func: F) -> Option<R>

Trait Implementations

impl<T, U, A> Add<ReactiveStateAccess<T, U, A>> for ReactiveStateAccess<T, U, A> where
    T: Copy + Add<Output = T> + 'static, 

type Output = T

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, U, A> ChangedAtomState for ReactiveStateAccess<T, U, A> where
    T: Clone + 'static + PartialEq, 

fn changed(&self) -> bool

impl<T, U, A> Clone for ReactiveStateAccess<T, U, A>

fn clone(&self) -> ReactiveStateAccess<T, U, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, U, A> CloneReactiveState<T> for ReactiveStateAccess<T, U, A> where
    T: Clone + 'static, 

fn get(&self) -> T

returns a clone of the stored state panics if not stored.

fn soft_get(&self) -> Option<T>

impl<T, U, A> Copy for ReactiveStateAccess<T, U, A>

impl<T, U, A> Debug for ReactiveStateAccess<T, U, A>

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

Formats the value using the given formatter.

impl<T, U, A> Display for ReactiveStateAccess<T, U, A> where
    T: Display + 'static, 

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

Formats the value using the given formatter.

impl<T, U, A> Div<ReactiveStateAccess<T, U, A>> for ReactiveStateAccess<T, U, A> where
    T: Copy + Div<Output = T> + 'static, 

type Output = T

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, U, A> Mul<ReactiveStateAccess<T, U, A>> for ReactiveStateAccess<T, U, A> where
    T: Copy + Mul<Output = T> + 'static, 

type Output = T

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, U, A> Observable<T> for ReactiveStateAccess<T, U, A> where
    T: 'static, 

fn observe(&self) -> T where
    T: Clone, 

fn observe_with<F: FnOnce(&T) -> R, R>(&self, func: F) -> R

impl<T, U, A> ObservableVec<T, U, A> for ReactiveStateAccess<Vec<T>, U, A> where
    T: 'static, 

fn observe_and_filter<F: FnMut(usize, &T) -> Option<usize>>(
    &self,
    func: F
) -> FilterVec<T, U, A>

impl<T, U, A, UB, AB> ObservableVec<T, U, A> for ReactiveStateAccess<FilterVec<T, U, A>, UB, AB> where
    T: 'static, 

fn observe_and_filter<F: FnMut(usize, &T) -> Option<usize>>(
    &self,
    func: F
) -> FilterVec<T, U, A>

impl<T> OverloadedUpdateStateAccess<T> for ReactiveStateAccess<T, NoUndo, IsAnAtomState> where
    T: 'static, 

fn overloaded_undo(&self)

fn overloaded_reset_to_default(&self)

fn overloaded_update<F: FnOnce(&mut T)>(&self, func: F)

fn overloaded_inert_set(self, value: T)

fn overloaded_set(self, value: T)

impl<T> OverloadedUpdateStateAccess<T> for ReactiveStateAccess<T, AllowUndo, IsAnAtomState> where
    T: Clone + 'static, 

fn overloaded_reset_to_default(&self)

fn overloaded_undo(&self)

fn overloaded_update<F: FnOnce(&mut T)>(&self, func: F)

fn overloaded_inert_set(self, value: T)

fn overloaded_set(self, value: T)

impl<T, U, A> Sub<ReactiveStateAccess<T, U, A>> for ReactiveStateAccess<T, U, A> where
    T: Copy + Sub<Output = T> + 'static, 

type Output = T

The resulting type after applying the - operator.

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

Performs the - operation.