#state #mutable #applications

app-state

Thread-safe, mutable application states for rust

1 unstable release

0.1.0 Sep 15, 2023

#69 in #mutable

Download history 124/week @ 2024-07-03 64/week @ 2024-07-10 17/week @ 2024-07-17 6/week @ 2024-07-24 1/week @ 2024-07-31 10/week @ 2024-08-07 257/week @ 2024-08-14 226/week @ 2024-08-21 158/week @ 2024-08-28 73/week @ 2024-09-04 32/week @ 2024-09-11 33/week @ 2024-09-18 52/week @ 2024-09-25 57/week @ 2024-10-02 39/week @ 2024-10-09 89/week @ 2024-10-16

246 downloads per month

Custom license

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