Moved state

src/state.rs

@@ -0,0 +1,97 @@
+use std::{
+    fmt::{Debug, Display, Formatter, Result as FmtResult},
+    ops::{Deref, DerefMut},
+    sync::{Arc, Mutex, MutexGuard},
+};
+
+#[derive(Debug, Clone)]
+pub struct State<T> {
+    inner: Arc<Mutex<Inner<T>>>,
+}
+
+#[derive(Debug)]
+pub struct Inner<T> {
+    value: T,
+    dependencies: usize,
+    changed: usize,
+}
+
+pub fn use_state<T>(v: T) -> State<T> {
+    State {
+        inner: Arc::new(Mutex::new(Inner {
+            value: v,
+            dependencies: 0,
+            changed: 0,
+        })),
+    }
+}
+
+impl<T: Clone> State<T> {
+    /// Gets the cloned value, recommended for preventing deadlocks
+    pub fn get_dl(&self) -> T {
+        self.inner.lock().unwrap().value.clone()
+    }
+}
+
+impl<T> State<T> {
+    /// Gets a lock on the state for read/write access.
+    pub fn get(&self) -> MutexGuard<'_, Inner<T>> {
+        self.inner.lock().unwrap()
+    }
+
+    /// Sets the value and marks it as changed.
+    pub fn set(&self, v: T) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.value = v;
+        inner.changed = inner.dependencies;
+    }
+
+    /// Marks the state as updated.
+    pub fn update(&self) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.changed = inner.dependencies;
+    }
+}
+
+impl<T: Debug + Send + Sync> DependencyHandler for State<T> {
+    fn check(&self) -> bool {
+        let mut inner = self.inner.lock().unwrap();
+        let i = inner.changed > 0;
+        if i {
+            inner.changed -= 1;
+        }
+        i
+    }
+
+    fn add(&self) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.dependencies += 1;
+    }
+}
+
+impl<T: Display> Display for State<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        let inner = self.inner.lock().unwrap();
+        write!(f, "{}", inner.value)
+    }
+}
+
+impl<T> Deref for Inner<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+impl<T> DerefMut for Inner<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.changed = self.dependencies;
+        &mut self.value
+    }
+}
+
+pub trait DependencyHandler: std::fmt::Debug + Send + Sync {
+    fn add(&self);
+    fn check(&self) -> bool;
+}