async_foundation/common/
ready_future_state.rs

1use std::{fmt::Debug, task::Waker};
2
3pub struct ReadyFutureState<T> {
4    pub(crate) waker: Option<Waker>,
5    pub(crate) result: ReadyFutureResult<T>,
6}
7
8impl<T> ReadyFutureState<T> {
9    pub fn new() -> ReadyFutureState<T> {
10        ReadyFutureState {
11            waker: None,
12            result: ReadyFutureResult::Pending,
13        }
14    }
15
16    pub fn new_completed(value: T) -> ReadyFutureState<T> {
17        ReadyFutureState {
18            waker: None,
19            result: ReadyFutureResult::Completed(value),
20        }
21    }
22
23    pub fn is_fulfilled(&self) -> bool {
24        !self.is_pending()
25    }
26
27    pub fn is_aborted(&self) -> bool {
28        matches!(self.result, ReadyFutureResult::Aborted)
29    }
30
31    pub fn is_timeouted(&self) -> bool {
32        matches!(self.result, ReadyFutureResult::Timeout)
33    }
34
35    pub fn is_terminated(&self) -> bool {
36        matches!(self.result, ReadyFutureResult::Terminated)
37    }
38
39    pub fn is_pending(&self) -> bool {
40        matches!(self.result, ReadyFutureResult::Pending)
41    }
42
43    pub fn is_completed(&self) -> bool {
44        matches!(self.result, ReadyFutureResult::Completed(_))
45    }
46
47    pub fn abort(&mut self) {
48        self.result = ReadyFutureResult::Aborted;
49        self.wake();
50    }
51
52    pub fn timeout(&mut self) {
53        self.result = ReadyFutureResult::Timeout;
54        self.wake();
55    }
56
57    pub fn complete(&mut self, val: T) {
58        self.result = ReadyFutureResult::Completed(val);
59        self.wake();
60    }
61
62    pub(crate) fn wake(&mut self) {
63        if let Some(waker) = self.waker.take() {
64            waker.wake()
65        }
66    }
67
68    pub fn terminate(&mut self) {
69        self.result = ReadyFutureResult::Terminated;
70    }
71}
72
73#[derive(Clone, Debug)]
74pub enum ReadyFutureResult<T> {
75    Completed(T),
76    Timeout,
77    Aborted,
78    Pending,
79    Terminated,
80}
81
82impl<T: Debug> Debug for ReadyFutureState<T> {
83    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
84        f.debug_struct("ReadyFutureState")
85            .field("waker", &self.waker)
86            .field("result", &self.result)
87            .finish()
88    }
89}
90
91#[cfg(test)]
92mod tests {
93    use super::*;
94    use std::sync::atomic::{AtomicBool, Ordering};
95    use std::task::Wake;
96
97    struct TestWaker {
98        woken: std::sync::Arc<AtomicBool>,
99    }
100
101    impl Wake for TestWaker {
102        fn wake(self: std::sync::Arc<Self>) {
103            self.woken.store(true, Ordering::SeqCst);
104        }
105    }
106
107    #[test]
108    fn test_new_state() {
109        let state = ReadyFutureState::<i32>::new();
110        assert!(state.is_pending());
111        assert!(!state.is_fulfilled());
112        assert!(!state.is_completed());
113        assert!(!state.is_aborted());
114        assert!(!state.is_timeouted());
115        assert!(!state.is_terminated());
116        assert!(state.waker.is_none());
117    }
118
119    #[test]
120    fn test_new_completed_state() {
121        let state = ReadyFutureState::new_completed(42);
122        assert!(!state.is_pending());
123        assert!(state.is_fulfilled());
124        assert!(state.is_completed());
125        assert!(!state.is_aborted());
126        assert!(!state.is_timeouted());
127        assert!(!state.is_terminated());
128        assert!(state.waker.is_none());
129    }
130
131    #[test]
132    fn test_abort() {
133        let mut state = ReadyFutureState::<i32>::new();
134        assert!(state.is_pending());
135        
136        state.abort();
137        assert!(!state.is_pending());
138        assert!(state.is_fulfilled());
139        assert!(state.is_aborted());
140        assert!(!state.is_completed());
141        assert!(!state.is_timeouted());
142        assert!(!state.is_terminated());
143    }
144
145    #[test]
146    fn test_timeout() {
147        let mut state = ReadyFutureState::<i32>::new();
148        assert!(state.is_pending());
149        
150        state.timeout();
151        assert!(!state.is_pending());
152        assert!(state.is_fulfilled());
153        assert!(state.is_timeouted());
154        assert!(!state.is_completed());
155        assert!(!state.is_aborted());
156        assert!(!state.is_terminated());
157    }
158
159    #[test]
160    fn test_complete() {
161        let mut state = ReadyFutureState::<i32>::new();
162        assert!(state.is_pending());
163        
164        state.complete(123);
165        assert!(!state.is_pending());
166        assert!(state.is_fulfilled());
167        assert!(state.is_completed());
168        assert!(!state.is_aborted());
169        assert!(!state.is_timeouted());
170        assert!(!state.is_terminated());
171    }
172
173    #[test]
174    fn test_terminate() {
175        let mut state = ReadyFutureState::<i32>::new();
176        assert!(state.is_pending());
177        
178        state.terminate();
179        assert!(!state.is_pending());
180        assert!(state.is_fulfilled());
181        assert!(state.is_terminated());
182        assert!(!state.is_completed());
183        assert!(!state.is_aborted());
184        assert!(!state.is_timeouted());
185    }
186
187    #[test]
188    fn test_waker_invocation_on_abort() {
189        let mut state = ReadyFutureState::<i32>::new();
190        let woken = std::sync::Arc::new(AtomicBool::new(false));
191        let waker = std::sync::Arc::new(TestWaker {
192            woken: woken.clone(),
193        });
194        let waker = std::task::Waker::from(waker);
195        
196        state.waker = Some(waker);
197        assert!(!woken.load(Ordering::SeqCst));
198        
199        state.abort();
200        assert!(woken.load(Ordering::SeqCst));
201        assert!(state.waker.is_none()); // Waker should be consumed
202    }
203
204    #[test]
205    fn test_waker_invocation_on_timeout() {
206        let mut state = ReadyFutureState::<i32>::new();
207        let woken = std::sync::Arc::new(AtomicBool::new(false));
208        let waker = std::sync::Arc::new(TestWaker {
209            woken: woken.clone(),
210        });
211        let waker = std::task::Waker::from(waker);
212        
213        state.waker = Some(waker);
214        assert!(!woken.load(Ordering::SeqCst));
215        
216        state.timeout();
217        assert!(woken.load(Ordering::SeqCst));
218        assert!(state.waker.is_none()); // Waker should be consumed
219    }
220
221    #[test]
222    fn test_waker_invocation_on_complete() {
223        let mut state = ReadyFutureState::<i32>::new();
224        let woken = std::sync::Arc::new(AtomicBool::new(false));
225        let waker = std::sync::Arc::new(TestWaker {
226            woken: woken.clone(),
227        });
228        let waker = std::task::Waker::from(waker);
229        
230        state.waker = Some(waker);
231        assert!(!woken.load(Ordering::SeqCst));
232        
233        state.complete(456);
234        assert!(woken.load(Ordering::SeqCst));
235        assert!(state.waker.is_none()); // Waker should be consumed
236    }
237
238    #[test]
239    fn test_no_waker_no_invocation() {
240        let mut state = ReadyFutureState::<i32>::new();
241        let woken = std::sync::Arc::new(AtomicBool::new(false));
242        let waker = std::sync::Arc::new(TestWaker {
243            woken: woken.clone(),
244        });
245        let _waker = std::task::Waker::from(waker);
246        
247        assert!(state.waker.is_none());
248        assert!(!woken.load(Ordering::SeqCst));
249        
250        state.abort();
251        assert!(!woken.load(Ordering::SeqCst)); // Should not invoke waker
252    }
253
254    #[test]
255    fn test_ready_future_result_debug() {
256        let result = ReadyFutureResult::Completed(42);
257        let debug_str = format!("{:?}", result);
258        assert!(debug_str.contains("Completed"));
259        assert!(debug_str.contains("42"));
260        
261        let result = ReadyFutureResult::<i32>::Pending;
262        let debug_str = format!("{:?}", result);
263        assert!(debug_str.contains("Pending"));
264        
265        let result = ReadyFutureResult::<i32>::Aborted;
266        let debug_str = format!("{:?}", result);
267        assert!(debug_str.contains("Aborted"));
268        
269        let result = ReadyFutureResult::<i32>::Timeout;
270        let debug_str = format!("{:?}", result);
271        assert!(debug_str.contains("Timeout"));
272        
273        let result = ReadyFutureResult::<i32>::Terminated;
274        let debug_str = format!("{:?}", result);
275        assert!(debug_str.contains("Terminated"));
276    }
277
278    #[test]
279    fn test_ready_future_result_clone() {
280        let result1 = ReadyFutureResult::Completed(42);
281        let result2 = result1.clone();
282        
283        match (result1, result2) {
284            (ReadyFutureResult::Completed(v1), ReadyFutureResult::Completed(v2)) => {
285                assert_eq!(v1, v2);
286            }
287            _ => panic!("Clone should preserve the value"),
288        }
289        
290        let result1 = ReadyFutureResult::<i32>::Pending;
291        let result2 = result1.clone();
292        assert!(matches!(result1, ReadyFutureResult::Pending));
293        assert!(matches!(result2, ReadyFutureResult::Pending));
294    }
295
296    #[test]
297    fn test_state_debug_formatting() {
298        let state = ReadyFutureState::<i32>::new();
299        let debug_str = format!("{:?}", state);
300        assert!(debug_str.contains("ReadyFutureState"));
301        assert!(debug_str.contains("waker"));
302        assert!(debug_str.contains("result"));
303    }
304}
async_foundation/common/ready_future_state.rs

async_foundation/common/
ready_future_state.rs
