1 unstable release
0.1.0 | Sep 15, 2023 |
---|
#72 in #mutable
191 downloads per month
28KB
690 lines
Thread-safe, mutable application states for rust.
Examples
Initializing the state
Any app state that may be used must be initialized first.
Note: An AppState
can not be used as a MutAppState
and vice versa.
This means that AppState
and MutAppState
must be initialized separately
and use independent values, even if they are of the same type.
use app_state::{AppState, MutAppState, AppStateTrait};
struct MyState {
counter: u32,
}
fn main() {
// Initialize the app state
AppState::init(MyState { counter: 0 });
// Initialize the mutable app state
MutAppState::init(MyState { counter: 0 });
}
Using derive
In order to avoid boilerplate code, the InitAppState
and InitMutAppState
traits can be derived for any struct. These traits provide the init_app_state
and init_mut_app_state
methods respectively which can be used to initialize
the state more easily.
use app_state::{AppState, MutAppState, AppStateTrait, InitAppState, InitMutAppState};
#[derive(Default, InitAppState, InitMutAppState)]
struct MyState {
counter: u32,
}
fn main() {
MyState::default().init_app_state();
MyState::default().init_mut_app_state();
}
Read-only state
App states internally use Arc
to allow for thread-safe access.
use app_state::{AppState, AppStateTrait, stateful};
struct MyState {
counter: u32,
}
#[stateful]
fn func(state: AppState<MyState>) {
println!("Counter: {}", state.counter);
}
Mutable state
Mutable states internally use a Mutex
to ensure thread-safety.
This means that when reading from or writing to the state, the mutex must be locked.
This can be done either by calling get_mut()
or by using the MutAppStateLock
type.
use app_state::{MutAppState, AppStateTrait, stateful};
struct MyState {
counter: u32,
}
#[stateful]
fn func(state: MutAppState<MyState>) {
let mut state = state.get_mut();
state.counter += 1;
}
Mutable state (locked)
In order to mutate the state, you must first lock it.
This can be done either by calling get_mut()
or by using the MutAppStateLock
type.
use app_state::{MutAppState, MutAppStateLock, AppStateTrait, stateful};
struct MyState {
counter: u32,
}
#[stateful]
fn func(mut state: MutAppStateLock<MyState>) {
state.counter += 1;
}
Get the state manually
You can also get the state manually by calling AppState::get()
or MutAppState::get()
.
use app_state::{AppState, MutAppState, AppStateTrait};
struct MyState {
counter: u32,
}
fn main() {
let state = AppState::<MyState>::get();
let mut_state = MutAppState::<MyState>::get();
}
Dependencies
~0.5–1MB
~22K SLoC