app-state 0.1.0

Thread-safe, mutable application states for rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

use crate::MutAppState;
use std::ops::{Deref, DerefMut};
use std::sync::MutexGuard;

/// The lock guard for a mutable app state.
/// This is a wrapper around `MutexGuard`.
/// When this guard is dropped, the lock will be released.
/// As this locks the state, no other thread can access the state until this guard is dropped.
///
/// # Examples
/// ```rust
/// use app_state::{MutAppState, MutAppStateLock, AppStateTrait, stateful};
///
/// struct MyState {
///   counter: u32,
/// }
///
/// #[stateful]
/// fn func(mut state: MutAppStateLock<MyState>) {
///   state.counter += 1;
/// }
/// ```
pub struct MutAppStateLock<'a, T: ?Sized>(MutexGuard<'a, T>);

impl<'a, T: 'static + Send> MutAppStateLock<'a, T> {
    pub fn new(inner: &'a MutAppState<T>) -> MutAppStateLock<'a, T> {
        MutAppStateLock(inner.lock().unwrap())
    }
}

impl<'a, T: ?Sized> MutAppStateLock<'a, T> {
    /// Returns reference to inner `T`.
    pub fn get_ref(&self) -> &MutexGuard<'a, T> {
        &self.0
    }

    /// Unwraps to the internal `Arc<T>`
    pub fn into_inner(self) -> MutexGuard<'a, T> {
        self.0
    }
}

impl<'a, T: ?Sized> Deref for MutAppStateLock<'a, T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

impl<'a, T: ?Sized> DerefMut for MutAppStateLock<'a, T> {
    fn deref_mut(&mut self) -> &mut T {
        &mut self.0
    }
}