redux-rs 0.3.3

A Rust implementation of Redux.
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

mod dispatch;
mod mailbox;
mod select;
mod subscribe;
mod work;

pub use dispatch::Dispatch;
pub use mailbox::{Address, Mailbox};
pub use select::Select;
pub use subscribe::Subscribe;
pub use work::Work;

use crate::{Reducer, Selector, Subscriber};
use async_trait::async_trait;
use work::HandleWork;

pub struct StateWorker<State, Action, RootReducer>
where
    State: Send,
    RootReducer: Send,
{
    mailbox: Mailbox<State, Action, RootReducer>,
    root_reducer: RootReducer,
    state: Option<State>,

    subscribers: Vec<Box<dyn Subscriber<State> + Send>>,
}

impl<State, Action, RootReducer> StateWorker<State, Action, RootReducer>
where
    RootReducer: Reducer<State, Action>,
    State: Send,
    RootReducer: Send,
{
    pub fn new(root_reducer: RootReducer, state: State) -> Self {
        Self {
            mailbox: Mailbox::new(),
            root_reducer,
            state: Some(state),

            subscribers: Default::default(),
        }
    }

    pub fn address(&self) -> Address<State, Action, RootReducer> {
        self.mailbox.address()
    }

    pub async fn run(&mut self) {
        while let Some(work) = self.mailbox.recv().await {
            work.execute(self).await;
        }
    }
}

#[async_trait]
impl<State, Action, RootReducer> HandleWork<Dispatch<Action>> for StateWorker<State, Action, RootReducer>
where
    RootReducer: Reducer<State, Action>,
    State: Send,
    RootReducer: Send,
    Action: Send,
{
    async fn handle_work(&mut self, work: Dispatch<Action>) {
        let action = work.into_action();

        let old_state = self.state.take().unwrap();
        let new_state = self.root_reducer.reduce(old_state, action);

        self.state = Some(new_state);

        if !self.subscribers.is_empty() {
            let new_state = self.state.as_ref().unwrap();
            for subscriber in &self.subscribers {
                subscriber.notify(new_state)
            }
        }
    }
}

#[async_trait]
impl<State, Action, RootReducer, S, Result> HandleWork<Select<State, S>> for StateWorker<State, Action, RootReducer>
where
    RootReducer: Reducer<State, Action>,
    State: Send,
    RootReducer: Send,
    S: Selector<State, Result = Result> + Send + 'static,
    Result: Send,
{
    async fn handle_work(&mut self, work: Select<State, S>) -> Result {
        let state = self.state.as_ref().unwrap();
        let selector = work.into_selector();
        selector.select(state)
    }
}

#[async_trait]
impl<State, Action, RootReducer> HandleWork<Subscribe<State>> for StateWorker<State, Action, RootReducer>
where
    RootReducer: Reducer<State, Action>,
    State: Send,
    RootReducer: Send,
{
    async fn handle_work(&mut self, work: Subscribe<State>) {
        let subscriber = work.into_subscriber();
        self.subscribers.push(subscriber);
    }
}