intrepid-core 0.3.0

Manage complex async business logic with ease
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use crate::{Action, ActionContext, Actions, BoxedAction, Frame, FrameFuture, Handler};

use super::{Open, Stateful, Stateless};

/// A system that is still being initialized.
#[derive(Clone)]
pub struct Batch<Status, State> {
    actions: Actions<State>,
    status: Status,
}

impl<Status, State> Batch<Status, State>
where
    State: Clone + Send + Sync + 'static,
{
    /// Add an action to the system.
    pub fn on_frame<ActionHandler, Args>(mut self, action: ActionHandler) -> Self
    where
        ActionHandler: Handler<Args, State> + Clone + Send + Sync + 'static,
        Args: Clone + Send + Sync + 'static,
    {
        self.actions.push(Box::new(Action::new(action)));
        self
    }

    /// Get the (empty) action context for this system.
    pub fn action_context(&self) -> ActionContext<State> {
        ActionContext::Unit
    }

    /// Handle a frame and state with this system.
    pub fn handle_frame_with_state(&self, frame: Frame, state: State) -> FrameFuture {
        let actions = self.actions.clone();

        FrameFuture::from_async_block(async move { handle_direct(actions, state, frame).await })
    }
}

impl<State> Batch<Open, State> {
    /// Create a new direct system with a given state. Direct systems do not route message
    /// frames to matching patterns, but instead invoke all actions.
    pub fn init() -> Self {
        Batch {
            status: Open,
            actions: Actions::new(),
        }
    }

    /// Transition to a stateful system with a given state.
    pub fn with_state(&self, state: State) -> Batch<Stateful<State>, State> {
        Batch {
            actions: self.actions.clone(),
            status: Stateful(state),
        }
    }
}

impl Batch<Open, ()> {
    /// Handle a frame and state with this system.
    pub fn handle_frame(self, frame: Frame) -> FrameFuture {
        self.handle_frame_with_state(frame, ())
    }

    /// Create a new direct system without state.
    pub fn without_state(self) -> Batch<Stateless, ()> {
        Batch {
            actions: self.actions,
            status: Stateless,
        }
    }
}

impl Batch<Stateless, ()> {
    /// Handle a frame and state with this system.
    pub fn handle_frame(self, frame: Frame) -> FrameFuture {
        self.handle_frame_with_state(frame, ())
    }
}

impl<State> Batch<Stateful<State>, State>
where
    State: Clone + Send + 'static,
{
    /// Get the state for this system.
    pub fn state(&self) -> State {
        self.status.0.clone()
    }

    /// Handle a frame with this system.
    pub fn handle_frame(self, frame: Frame) -> FrameFuture {
        let actions = self.actions.clone();
        let state = self.state();

        FrameFuture::from_async_block(async move { handle_direct(actions, state, frame).await })
    }
}

async fn handle_direct<State>(
    actions: Vec<BoxedAction<State>>,
    state: State,
    frame: Frame,
) -> crate::Result<Frame>
where
    State: Clone + Send + 'static,
{
    let mut responses = vec![];

    for action in actions.into_iter() {
        responses.push(
            action
                .into_actionable(state.clone())
                .handle_frame(frame.clone())
                .await?,
        );
    }

    Ok(responses.into())
}

#[tokio::test]
async fn calling_with_a_frame_statelessly() -> Result<(), tower::BoxError> {
    assert_eq!(
        Batch::init()
            .without_state()
            .handle_frame(Frame::default())
            .await?,
        Frame::default()
    );

    assert_eq!(
        Batch::init().handle_frame(Frame::default()).await?,
        Frame::default()
    );

    Ok(())
}

#[tokio::test]
async fn calling_with_a_frame_statefully() -> Result<(), tower::BoxError> {
    #[derive(Clone)]
    struct ArbitraryState;
    let result = Batch::init()
        .with_state(ArbitraryState)
        .handle_frame(Frame::default())
        .await;

    assert_eq!(result?, Frame::default());

    Ok(())
}