Improved state structure
This commit is contained in:
@@ -0,0 +1,55 @@
|
||||
//! # Effect hooks module
|
||||
//!
|
||||
//! Provides React-like use_effect hooks for managing effects.
|
||||
//! This module includes use_effect and use_sync_effect.
|
||||
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use super::{state::State, HookDependency, HookEffect};
|
||||
use crate::component::context::Context;
|
||||
|
||||
/// Executes a function when dependencies change
|
||||
///
|
||||
/// Similar to React's useEffect. The provided function is executed
|
||||
/// when any of the dependencies change.
|
||||
pub fn use_effect<F: FnMut() + Send + Sync + 'static>(f: F, dependencies: &[&dyn HookDependency]) {
|
||||
let f = Arc::new(Mutex::new(f));
|
||||
let hook = HookEffect(Arc::new(Mutex::new({
|
||||
let f = f.clone();
|
||||
move || {
|
||||
let f = f.clone();
|
||||
std::thread::spawn(move || (f.lock().unwrap())());
|
||||
}
|
||||
})));
|
||||
|
||||
for d in dependencies {
|
||||
d.on_update(hook.clone());
|
||||
}
|
||||
}
|
||||
|
||||
/// Synchronizes state changes back to the context as events
|
||||
///
|
||||
/// Creates an effect that emits an event whenever the state changes.
|
||||
/// The encoder function converts state values to events.
|
||||
pub fn use_sync_effect<
|
||||
T: Send + Sync + 'static,
|
||||
Ev: Send + Sync + 'static,
|
||||
E: Fn(&State<T>) -> Ev + Send + Sync + 'static,
|
||||
>(
|
||||
cx: &Arc<Context>,
|
||||
state: &State<T>,
|
||||
encoder: E,
|
||||
deps: &[&dyn HookDependency],
|
||||
) {
|
||||
use_effect(
|
||||
{
|
||||
let state = state.clone();
|
||||
let cx = cx.clone();
|
||||
move || {
|
||||
let ev = encoder(&state);
|
||||
cx.emit_event(ev);
|
||||
}
|
||||
},
|
||||
deps,
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
//! # State Management and Hooks Module
|
||||
//!
|
||||
//! Provides React-like hooks for managing component state and side effects.
|
||||
//! This module includes useState, useEffect, useMount, and state synchronization hooks.
|
||||
|
||||
use std::{
|
||||
fmt::{Debug, Formatter, Result as FmtResult},
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
|
||||
mod effect;
|
||||
mod mount;
|
||||
mod state;
|
||||
pub use effect::*;
|
||||
pub use mount::*;
|
||||
pub use state::*;
|
||||
|
||||
/// Effect callback that can be triggered by state changes
|
||||
#[derive(Clone)]
|
||||
pub struct HookEffect(Arc<Mutex<dyn FnMut() + Send + Sync>>);
|
||||
|
||||
/// Trait for values that can be tracked as dependencies in hooks
|
||||
pub trait HookDependency: Send + Sync {
|
||||
/// Register an effect to be triggered on updates
|
||||
fn on_update(&self, hook: HookEffect);
|
||||
}
|
||||
|
||||
impl HookEffect {
|
||||
/// Creates a new effect from a function
|
||||
pub fn new<F: Fn() + Send + Sync + 'static>(f: F) -> Self {
|
||||
Self(Arc::new(Mutex::new(f)))
|
||||
}
|
||||
|
||||
/// Executes the effect function
|
||||
pub fn call(&self) {
|
||||
(self.0.lock().unwrap())()
|
||||
}
|
||||
}
|
||||
|
||||
impl Debug for HookEffect {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
|
||||
write!(f, "HookEffect")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
//! # Mount hooks module
|
||||
//!
|
||||
//! Provides React-like Mount hooks for managing effects.
|
||||
//! This module includes Mount, use_mount and use_mount_manual.
|
||||
|
||||
use std::{
|
||||
fmt::Debug,
|
||||
sync::{Arc, Mutex},
|
||||
};
|
||||
|
||||
use super::{HookDependency, HookEffect};
|
||||
|
||||
/// Mount lifecycle hook
|
||||
///
|
||||
/// Tracks whether a component has been mounted and executes
|
||||
/// any pending mount effects.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Mount(Arc<Mutex<bool>>, Arc<Mutex<Vec<HookEffect>>>);
|
||||
|
||||
/// Creates a mount lifecycle hook
|
||||
///
|
||||
/// Returns a Mount that tracks component lifecycle and executes
|
||||
/// effects after mounting.
|
||||
pub fn use_mount() -> Mount {
|
||||
Mount(Arc::new(Mutex::new(true)), Arc::new(Mutex::new(Vec::new())))
|
||||
}
|
||||
|
||||
/// Creates a manual mount lifecycle hook
|
||||
///
|
||||
/// Similar to use_mount but the component starts as unmounted.
|
||||
/// Must call .mount() to trigger mounted effects.
|
||||
pub fn use_mount_manual() -> Mount {
|
||||
Mount(
|
||||
Arc::new(Mutex::new(false)),
|
||||
Arc::new(Mutex::new(Vec::new())),
|
||||
)
|
||||
}
|
||||
|
||||
impl HookDependency for Mount {
|
||||
fn on_update(&self, hook: HookEffect) {
|
||||
if *self.0.lock().unwrap() {
|
||||
hook.call();
|
||||
} else {
|
||||
self.1.lock().unwrap().push(hook);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Mount {
|
||||
/// Mark the component as mounted and execute pending effects
|
||||
pub fn mount(&self) {
|
||||
*self.0.lock().unwrap() = true;
|
||||
for hook_effect in self.1.lock().unwrap().iter() {
|
||||
hook_effect.call();
|
||||
}
|
||||
self.1.lock().unwrap().clear();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
//! # State hooks module
|
||||
//!
|
||||
//! Provides React-like use_state hooks for managing states.
|
||||
//! This module includes use_state and use_sync_state.
|
||||
|
||||
use std::{
|
||||
any::Any,
|
||||
fmt::{Debug, Display, Formatter, Result as FmtResult},
|
||||
ops::{Deref, DerefMut},
|
||||
sync::{Arc, Mutex, MutexGuard},
|
||||
};
|
||||
|
||||
use super::{HookDependency, HookEffect};
|
||||
use crate::component::context::Context;
|
||||
|
||||
/// State holder for reactive values
|
||||
///
|
||||
/// Similar to React's useState hook. Holds a value and tracks dependents
|
||||
/// that need to be notified when the value changes.
|
||||
#[derive(Debug)]
|
||||
pub struct State<T> {
|
||||
/// The actual state value
|
||||
value: Arc<Mutex<T>>,
|
||||
/// Functions to call when state is updated
|
||||
dependents: Arc<Mutex<Vec<HookEffect>>>,
|
||||
}
|
||||
|
||||
/// Guard for accessing and potentially modifying state
|
||||
///
|
||||
/// Dereferences to the state value. When dropped after modification,
|
||||
/// automatically triggers all dependent effects.
|
||||
pub struct Inner<'a, T> {
|
||||
value: MutexGuard<'a, T>,
|
||||
dependents: Arc<Mutex<Vec<HookEffect>>>,
|
||||
updated: bool,
|
||||
}
|
||||
|
||||
impl<T: Clone> State<T> {
|
||||
/// Gets a cloned copy of the state value
|
||||
///
|
||||
/// Recommended over `get()` to prevent deadlocks when cloning is acceptable.
|
||||
/// "dl" stands for "deadlock-less".
|
||||
pub fn get_dl(&self) -> T {
|
||||
self.value.lock().unwrap().clone()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> State<T> {
|
||||
/// Acquires a lock on the state for read/write access
|
||||
///
|
||||
/// Returns an Inner guard that implements Deref and DerefMut.
|
||||
/// When dropped after modification, triggers dependent effects.
|
||||
pub fn get(&self) -> Inner<'_, T> {
|
||||
Inner {
|
||||
value: self.value.lock().unwrap(),
|
||||
dependents: self.dependents.clone(),
|
||||
updated: false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Sets the state value and triggers dependents
|
||||
pub fn set(&self, v: T) {
|
||||
*self.value.lock().unwrap() = v;
|
||||
self.update();
|
||||
}
|
||||
|
||||
/// Notifies all dependents of an update
|
||||
pub fn update(&self) {
|
||||
for d in self.dependents.lock().unwrap().iter() {
|
||||
d.call();
|
||||
}
|
||||
}
|
||||
|
||||
/// Clones the State handle (not the value)
|
||||
pub fn clone(&self) -> Self {
|
||||
Self {
|
||||
dependents: self.dependents.clone(),
|
||||
value: self.value.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Display> Display for State<T> {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
|
||||
write!(f, "{}", self.value.lock().unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
/// Inner implements Deref for read access and DerefMut for write access
|
||||
/// On drop after mutation, automatically triggers dependent effects
|
||||
impl<T> Drop for Inner<'_, T> {
|
||||
fn drop(&mut self) {
|
||||
if self.updated {
|
||||
for d in self.dependents.lock().unwrap().iter() {
|
||||
d.call();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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.updated = true;
|
||||
&mut self.value
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Send + Sync> HookDependency for State<T> {
|
||||
fn on_update(&self, hook: HookEffect) {
|
||||
self.dependents.lock().unwrap().push(hook);
|
||||
}
|
||||
}
|
||||
|
||||
/// Synchronizes state with events from the context
|
||||
///
|
||||
/// Creates state that is automatically updated when events are emitted
|
||||
/// to the context. The decoder function converts events to state values.
|
||||
pub fn use_sync_state<
|
||||
T: Send + Sync + 'static,
|
||||
E: Any + 'static,
|
||||
D: Fn(&E) -> T + Send + Sync + 'static,
|
||||
>(
|
||||
cx: &Arc<Context>,
|
||||
v: T,
|
||||
decoder: D,
|
||||
) -> State<T> {
|
||||
let state = use_state(v);
|
||||
|
||||
cx.on_event({
|
||||
let state = state.clone();
|
||||
move |_, v: &E| state.set(decoder(v))
|
||||
});
|
||||
|
||||
state
|
||||
}
|
||||
|
||||
/// Creates a new state value
|
||||
///
|
||||
/// Returns a State that can be read and written from multiple threads.
|
||||
pub fn use_state<T>(v: T) -> State<T> {
|
||||
State {
|
||||
value: Arc::new(Mutex::new(v)),
|
||||
dependents: Arc::new(Mutex::new(Vec::new())),
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user