1use futures_locks::RwLock;
2use futures_locks::RwLockReadGuard;
3use futures_locks::RwLockWriteGuard;
4use rkyv::{Archive, Deserialize, Serialize};
5use std::sync::Arc;
6
7#[derive(Archive, Debug, Deserialize, Serialize)]
8#[archive(bound(
9 serialize = "__S: rkyv::ser::ScratchSpace + rkyv::ser::SharedSerializeRegistry + rkyv::ser::Serializer",
10 deserialize = "__D: rkyv::de::SharedDeserializeRegistry"
11))]
12pub struct State {
13 pub active: i32,
14 pub current_tasks: Vec<i32>,
15 pub current_flows: Vec<i32>,
16 pub visited_tasks: Vec<i32>,
17 pub visited_flows: Vec<i32>,
18 pub pending_tasks: Vec<i32>,
19 pub maybe_future_tasks: Vec<i32>,
20 pub maybe_future_flows: Vec<i32>,
21 pub maybe_visited_tasks: Vec<i32>,
22 pub variables: wfrs_model::json::JsonValue,
23 pub completed: bool,
24 pub remote_id: Option<String>,
25 pub remote_version: Option<i64>,
26}
27
28pub struct LockedState {
29 pub inner: State,
30}
31
32#[derive(Clone)]
33pub struct WorkflowState {
34 inner: Arc<RwLock<LockedState>>,
35}
36
37impl WorkflowState {
38 pub fn new(start_event: i32) -> Self {
39 Self {
40 inner: Arc::new(RwLock::new(LockedState {
41 inner: State {
42 active: -1,
43 current_tasks: vec![start_event],
44 current_flows: vec![],
45 visited_tasks: vec![],
46 visited_flows: vec![],
47 pending_tasks: vec![],
48 maybe_future_tasks: vec![],
49 maybe_future_flows: vec![],
50 maybe_visited_tasks: vec![],
51 variables: wfrs_model::json::JsonValue::map(),
52 completed: false,
53 remote_id: None,
54 remote_version: None,
55 },
56 })),
57 }
58 }
59
60 pub fn from_state(state: State) -> Self {
61 Self {
62 inner: Arc::new(RwLock::new(LockedState { inner: state })),
63 }
64 }
65
66 pub async fn replace(&self, state: State) {
67 self.inner.write().await.inner = state;
68 }
69
70 pub async fn set_remote_id(&self, remote_id: String, remote_version: i64) {
71 let mut state = self.inner.write().await;
72 state.inner.remote_id = Some(remote_id);
73 state.inner.remote_version = Some(remote_version);
74 }
75
76 pub async fn get_remote_id(&self) -> Option<String> {
77 self.inner.read().await.inner.remote_id.clone()
78 }
79
80 pub async fn has_visited(&self, user_task: i32) -> bool {
81 let state = self.inner.read().await;
82 state.inner.visited_tasks.contains(&user_task)
83 }
84
85 pub async fn has_maybe_visited(&self, user_task: i32) -> bool {
86 let state = self.inner.read().await;
87 state.inner.maybe_visited_tasks.contains(&user_task)
88 }
89
90 pub async fn set_usertask(&self, user_task: i32) {
91 let mut state = self.inner.write().await;
92 state.inner.current_tasks.clear();
93 state.inner.current_flows.clear();
94 state.inner.pending_tasks.clear();
95 state.inner.pending_tasks.push(user_task);
96 state.inner.active = user_task;
97 }
98
99 pub async fn clear_future(&self, start_event: i32) {
100 let mut state = self.inner.write().await;
101 state.inner.maybe_future_tasks.clear();
102 state.inner.maybe_future_flows.clear();
103 state.inner.maybe_visited_tasks.clear();
104 state.inner.maybe_future_tasks.push(start_event);
105 }
106
107 pub async fn set_active(&self, active: i32) {
108 self.inner.write().await.inner.active = active;
109 }
110
111 pub async fn get_active(&self) -> i32 {
112 self.inner.read().await.inner.active
113 }
114
115 pub async fn set_completed(&self) {
116 self.inner.write().await.inner.completed = true;
117 }
118
119 pub async fn pop_current_task(&self) -> Option<i32> {
120 self.inner.write().await.inner.current_tasks.pop()
121 }
122
123 pub async fn push_current_task(&self, task: i32) {
124 self.inner.write().await.inner.current_tasks.push(task);
125 }
126
127 pub async fn pop_visited_task(&self) -> Option<i32> {
128 self.inner.write().await.inner.visited_tasks.pop()
129 }
130
131 pub async fn push_visited_task(&self, task: i32) {
132 let mut state = self.inner.write().await;
133 let exist = state.inner.visited_tasks.contains(&task);
134 if !exist {
135 state.inner.visited_tasks.push(task);
136 }
137 }
138
139 pub async fn pop_current_flow(&self) -> Option<i32> {
140 self.inner.write().await.inner.current_flows.pop()
141 }
142
143 pub async fn push_current_flow(&self, flow: i32) {
144 self.inner.write().await.inner.current_flows.push(flow);
145 }
146
147 pub async fn pop_visited_flow(&self) -> Option<i32> {
148 self.inner.write().await.inner.visited_flows.pop()
149 }
150
151 pub async fn push_visited_flow(&self, flow: i32) {
152 self.inner.write().await.inner.visited_flows.push(flow);
153 }
154
155 pub async fn pop_pending_task(&self) -> Option<i32> {
156 self.inner.write().await.inner.pending_tasks.pop()
157 }
158
159 pub async fn push_pending_task(&self, task: i32) {
160 self.inner.write().await.inner.pending_tasks.push(task);
161 }
162
163 pub async fn pop_maybe_future_task(&self) -> Option<i32> {
164 self.inner.write().await.inner.maybe_future_tasks.pop()
165 }
166
167 pub async fn push_maybe_future_task(&self, task: i32) {
168 self.inner.write().await.inner.maybe_future_tasks.push(task);
169 }
170
171 pub async fn push_maybe_visited_task(&self, task: i32) {
172 self.inner
173 .write()
174 .await
175 .inner
176 .maybe_visited_tasks
177 .push(task);
178 }
179
180 pub async fn pop_maybe_future_flow(&self) -> Option<i32> {
181 self.inner.write().await.inner.maybe_future_flows.pop()
182 }
183
184 pub async fn push_maybe_future_flow(&self, flow: i32) {
185 self.inner.write().await.inner.maybe_future_flows.push(flow);
186 }
187
188 pub async fn pending_task_by_index(&self, idx: usize) -> i32 {
189 self.inner.write().await.inner.pending_tasks.remove(idx)
190 }
191
192 pub async fn state(&self) -> RwLockReadGuard<LockedState> {
193 self.inner.read().await
194 }
195 pub async fn mut_state(&self) -> RwLockWriteGuard<LockedState> {
196 self.inner.write().await
197 }
198}