Struct State

pub struct State<T> { /* private fields */ }

Implementations

impl<T> State<T>

where T: Not<Output = T> + Clone + 'static,

pub fn toggled(&mut self) -> T

pub fn toggle(&mut self)

impl<T> State<T>

pub fn read(&self) -> <UnsyncStorage as AnyStorage>::Ref<'static, T>

pub fn peek(&self) -> <UnsyncStorage as AnyStorage>::Ref<'static, T>

pub fn write(&mut self) -> <UnsyncStorage as AnyStorage>::Mut<'static, T>

pub fn with_mut( &mut self, with: impl FnOnce(<UnsyncStorage as AnyStorage>::Mut<'static, T>), )

where T: 'static,

pub fn write_unchecked(&self) -> <UnsyncStorage as AnyStorage>::Mut<'static, T>

pub fn set(&mut self, value: T)

where T: 'static,

pub fn set_if_modified(&mut self, value: T)

where T: 'static + PartialEq,

pub fn set_if_modified_and_then(&mut self, value: T, then: impl FnOnce())

where T: 'static + PartialEq,

pub fn create(value: T) -> State<T>

where T: 'static,

Create a State attached to the current Scope.

pub fn create_in_scope( value: T, scope_id: impl Into<Option<ScopeId>>, ) -> State<T>

where T: 'static,

Create a State attached to the given Scope.

pub fn create_global(value: T) -> State<T>

where T: 'static,

Create a global State that is expected to live until the end of the process.

impl<T> State<Option<T>>

pub fn take(&mut self) -> Option<T>

where T: 'static,

Trait Implementations

impl<T> Clone for State<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Deref for State<T>

where T: Copy + 'static,

Allow calling the states as functions. Limited to Copy values only.

type Target = dyn Fn() -> T

The resulting type after dereferencing.

fn deref(&self) -> &<State<T> as Deref>::Target

Dereferences the value.

impl<T> From<State<T>> for ReadState<T>

fn from(value: State<T>) -> ReadState<T>

Converts to this type from the input type.

impl<T> MutView<'static, T> for State<T>

where T: 'static,

fn read(&mut self) -> <UnsyncStorage as AnyStorage>::Ref<'static, T>

fn peek(&mut self) -> <UnsyncStorage as AnyStorage>::Ref<'static, T>

fn write(&mut self) -> <UnsyncStorage as AnyStorage>::Mut<'static, T>

fn write_if( &mut self, with: impl FnOnce(<UnsyncStorage as AnyStorage>::Mut<'static, T>) -> bool, )

impl<T> PartialEq for State<T>

where T: 'static,

fn eq(&self, other: &State<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 State<T>

impl<T> Eq for State<T>

where T: 'static,