Struct this_state::State

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

A thread-safe state, that can be used to share application state globally.

It is similar to a RWLock<S>, but it also allows asynchronous waiting for state changes. This can be useful to coordinate between different parts of an application.

Implementations

impl<S> State<S>

pub fn new(state: S) -> Self

Creates a new state.

pub fn new_with_on_change( state: S, on_change: impl Fn(&S, &S) + 'static ) -> Self

Creates a new state with the given on_change callback.

Notes

The callback is not called when the state is set for the first time, as well as on the State::update method. You must call the callback manually in these cases.

pub fn get_ref(&self) -> StateRef<'_, S>

Returns a reference to the current state. This can be used if the state does not implement Clone or if you want to avoid cloning.

pub fn wait_for<C>(&self, wait_for: C) -> StateFuture<S, C> where C: Fn(&S) -> bool,

Returns a future that completes when the state matches the given predicate.

pub fn set(&self, state: S)

Sets the state to the given value.

pub fn update(&self, f: impl FnOnce(&mut S))

Updates the state using the given function. This avoids having to create a new state value, which can be useful for large state values.

Notes

This DOES NOT call the on_change callback, as it is not possible to get the old state.

impl<S> State<S>where S: Clone,

pub fn get(&self) -> S

Returns a clone of the current state. This is particularly useful for States that implement Copy.

impl<S> State<S>where S: PartialEq<S>,

pub fn wait_for_state(&self, wait_for: S) -> StateFuture<S, impl Fn(&S) -> bool>

Returns a future that resolves when the state is equal to the given value.

Trait Implementations

impl<S: Clone> Clone for State<S>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for State<S>

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

Formats the value using the given formatter.

impl<S: Default> Default for State<S>

fn default() -> Self

Returns the “default value” for a type.

impl<S, O> PartialEq<O> for State<S>where S: PartialEq<O>,

fn eq(&self, other: &O) -> 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<S> Send for State<S>

impl<S> Sync for State<S>