Struct State

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

Implementations

impl<T: Not<Output = T> + Clone + 'static> State<T>

pub fn toggled(&mut self) -> T

pub fn toggle(&mut self)

impl<T> State<T>

pub fn read(&self) -> ReadRef<'static, T>

pub fn peek(&self) -> ReadRef<'static, T>

pub fn write(&mut self) -> WriteRef<'static, T>

pub fn with_mut(&mut self, with: impl FnOnce(WriteRef<'static, T>))

where T: 'static,

pub fn write_unchecked(&self) -> WriteRef<'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) -> Self

where T: 'static,

Create a State attached to the current Scope.

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

where T: 'static,

Create a State attached to the given Scope.

pub fn create_global(value: T) -> Self

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) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + 'static> Deref for State<T>

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

type Target = dyn Fn() -> T

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Converts to this type from the input type.

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

fn read(&mut self) -> ReadRef<'static, T>

fn peek(&mut self) -> ReadRef<'static, T>

fn write(&mut self) -> WriteRef<'static, T>

fn write_if(&mut self, with: impl FnOnce(WriteRef<'static, T>) -> bool)

impl<T: 'static> PartialEq for State<T>

fn eq(&self, other: &Self) -> 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: 'static> Eq for State<T>