win_events/events/
manual_reset.rs

1use std::error::Error;
2use std::sync::atomic::{AtomicBool, Ordering};
3use std::sync::{Arc, MutexGuard};
4use std::time::Duration;
5
6use crate::events::event::{EventHandle, EventState};
7use crate::waiters::waiter::{Signaler, WaitList};
8use crate::{wait_one, Event};
9
10struct ManualResetEventInfo {
11    fired: AtomicBool,
12    waiters: WaitList,
13}
14
15impl ManualResetEventInfo {
16    fn new(init: bool) -> ManualResetEventInfo {
17        ManualResetEventInfo {
18            fired: AtomicBool::new(init),
19            waiters: WaitList::new(),
20        }
21    }
22}
23
24impl EventState for ManualResetEventInfo {
25    fn is_set(&self) -> bool {
26        self.fired.load(Ordering::Relaxed)
27    }
28
29    fn set(&self) {
30        self.fired.store(true, Ordering::Relaxed);
31        self.waiters.fire()
32    }
33
34    fn clear(&self) {
35        self.fired.store(false, Ordering::Relaxed);
36        self.waiters.clear();
37    }
38
39    fn register_signaler(
40        &self,
41        pos: usize,
42        signaler: Arc<dyn Signaler>,
43    ) -> Result<(), Box<dyn Error>> {
44        if self.is_set() {
45            signaler.fire(pos)?;
46        }
47        self.waiters.register_signaler(pos, signaler)
48    }
49
50    fn remove_signaler(&self, signaler: &Arc<dyn Signaler>) -> Result<(), Box<dyn Error>> {
51        self.waiters.remove_signaler(signaler)
52    }
53
54    fn wake_lock(&self) -> Result<Option<MutexGuard<()>>, Box<dyn Error>> {
55        Ok(None)
56    }
57
58    fn can_consume(&self) -> bool {
59        self.fired.load(Ordering::Relaxed)
60    }
61
62    fn consume(&self) {}
63}
64
65/// A ManualResetEvent
66///
67/// An event represents a boolean condition that can be waited on until signaled. This allows a
68/// thread to block and wait for another thread to set the event. Until the event is manually reset
69/// waiting will return immediately.
70///
71/// # Examples
72///
73/// ```
74/// use std::thread;
75/// use std::time::Duration;
76/// use win_events::{Event, ManualResetEvent};
77///
78/// let evt_started = ManualResetEvent::new(false);
79/// let evt_started2 = evt_started.clone();
80///
81/// // spawn a thread and set the cloned event
82/// thread::spawn(move|| {
83///     evt_started2.set();
84/// });
85///
86/// // Wait for the started event
87/// evt_started.wait(Duration::from_millis(100)).unwrap();
88/// ```
89#[derive(Clone)]
90pub struct ManualResetEvent {
91    info: Arc<EventHandle>,
92}
93
94impl ManualResetEvent {
95    /// Creates a new ManualResetEvent and initialized the value.
96    ///
97    /// # Examples
98    ///
99    /// ```
100    /// use win_events::ManualResetEvent;
101    ///
102    /// let evt = ManualResetEvent::new(false);
103    /// ```
104    pub fn new(init: bool) -> ManualResetEvent {
105        let state: Box<dyn EventState> = Box::new(ManualResetEventInfo::new(init));
106        ManualResetEvent {
107            info: Arc::new(EventHandle::new(state)),
108        }
109    }
110
111    /// Gets the current state of the event.
112    ///
113    /// # Examples
114    ///
115    /// ```
116    /// use win_events::ManualResetEvent;
117    ///
118    /// let evt = ManualResetEvent::new(true);
119    /// assert!(evt.is_set())
120    ///  ```
121    pub fn is_set(&self) -> bool {
122        self.info.is_set()
123    }
124
125    /// Sets the event and fires a signal to any threads waiting on the event.
126    ///
127    /// # Examples
128    ///
129    /// ```
130    /// use win_events::ManualResetEvent;
131    ///
132    /// let evt = ManualResetEvent::new(false);
133    /// evt.set();
134    /// assert!(evt.is_set())
135    /// ```
136    pub fn set(&self) {
137        self.info.set()
138    }
139
140    /// Sets the even, causing any waiting threads to receive a signal.
141    ///
142    /// # Examples
143    ///
144    /// ```
145    /// use win_events::ManualResetEvent;
146    ///
147    /// let evt = ManualResetEvent::new(false);
148    /// evt.clear();
149    /// assert!(!evt.is_set())
150    /// ```
151    pub fn clear(&self) {
152        self.info.clear()
153    }
154    /// Creates a new ManualResetEvent and initialized the value.
155    ///
156    /// # Examples
157    ///
158    /// ```
159    /// use std::thread::{sleep, spawn};
160    /// use std::time::Duration;
161    /// use win_events::ManualResetEvent;
162    ///
163    /// let evt = ManualResetEvent::new(false);
164    /// let evt_inner = evt.clone();
165    ///
166    /// let worker = spawn(move || {
167    ///    sleep(Duration::from_millis(3));
168    ///    evt_inner.set()
169    /// });
170    ///
171    /// let wait_result = evt.wait(Duration::from_millis(100)).unwrap();
172    /// assert!(wait_result)
173    /// ```
174    pub fn wait(&self, dur: Duration) -> Result<bool, Box<dyn Error>> {
175        wait_one(self, dur)
176    }
177}
178
179impl Event for ManualResetEvent {
180    fn handle(&self) -> &Arc<EventHandle> {
181        &self.info
182    }
183}
win_events/events/manual_reset.rs

win_events/events/
manual_reset.rs
