win_events/events/
pulse.rs

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

win_events/events/
pulse.rs
