win_events/events/
event.rs

1use std::error::Error;
2use std::sync::{Arc, MutexGuard};
3
4use crate::waiters::waiter::Signaler;
5
6/// Trait for each event type to implement
7pub(crate) trait EventState: Send + Sync {
8    /// Checks to see if the current EventState has been set
9    fn is_set(&self) -> bool;
10
11    /// Sets EventState
12    fn set(&self);
13
14    /// Clears the EventState
15    fn clear(&self);
16
17    /// Registers a signaler object with an event to notify waiting threads when an event is set
18    fn register_signaler(
19        &self,
20        pos: usize,
21        signaler: Arc<dyn Signaler>,
22    ) -> Result<(), Box<dyn Error>>;
23
24    /// Removes the signaler when a waiting thread continues
25    fn remove_signaler(&self, signaler: &Arc<dyn Signaler>) -> Result<(), Box<dyn Error>>;
26
27    /// An optional mutex if the event needs to be locked before consuming
28    fn wake_lock(&self) -> Result<Option<MutexGuard<()>>, Box<dyn Error>>;
29
30    /// Expected to be used with the wake lock, call can consume to see if the event is consumable
31    fn can_consume(&self) -> bool;
32
33    /// Expected to be used with the wake lock, tells the event a waiting thread is releasing and
34    /// consuming the event
35    fn consume(&self);
36}
37
38/// Wrapper struct passing around the internal state which is only accessible by this crate
39pub struct EventHandle {
40    state: Box<dyn EventState>,
41}
42
43impl EventHandle {
44    pub(crate) fn new(state: Box<dyn EventState>) -> EventHandle {
45        EventHandle { state }
46    }
47
48    pub(crate) fn is_set(&self) -> bool {
49        self.state.is_set()
50    }
51
52    pub(crate) fn set(&self) {
53        self.state.set()
54    }
55
56    pub(crate) fn clear(&self) {
57        self.state.clear()
58    }
59
60    pub(crate) fn wake_lock(&self) -> Result<Option<MutexGuard<()>>, Box<dyn Error>> {
61        self.state.wake_lock()
62    }
63
64    pub(crate) fn can_consume(&self) -> bool {
65        self.state.can_consume()
66    }
67
68    pub(crate) fn consume(&self) {
69        self.state.consume()
70    }
71}
72
73/// A public trait for passing in the events into a wait function, which gives access to the
74/// private EventHandle's state
75pub trait Event: Sync {
76    fn handle(&self) -> &Arc<EventHandle>;
77}
78
79pub(crate) fn try_consume_one(event: &dyn Event) -> Result<bool, Box<dyn Error>> {
80    let _ = event.handle().wake_lock()?;
81    if event.handle().can_consume() {
82        event.handle().consume();
83        Ok(true)
84    } else {
85        Ok(false)
86    }
87}
88
89pub(crate) fn try_consume_all(events: &Vec<&dyn Event>) -> Result<bool, Box<dyn Error>> {
90    let mut locks = Vec::with_capacity(events.len());
91
92    for event in events {
93        let wake_lock = event.handle().wake_lock()?;
94        if !event.handle().can_consume() {
95            return Ok(false);
96        }
97        locks.push(wake_lock)
98    }
99
100    for event in events {
101        event.handle().consume()
102    }
103
104    Ok(true)
105}
106
107pub(crate) struct AutoUnregister {
108    signaler: Arc<dyn Signaler>,
109    handle: Arc<EventHandle>,
110}
111
112impl AutoUnregister {
113    pub(crate) fn new(signaler: Arc<dyn Signaler>, handle: Arc<EventHandle>) -> AutoUnregister {
114        AutoUnregister { signaler, handle }
115    }
116
117    pub(crate) fn register_signaler(
118        signaler: Arc<dyn Signaler>,
119        pos: usize,
120        event: &dyn Event,
121    ) -> Result<AutoUnregister, Box<dyn Error>> {
122        let auto_unregister =
123            AutoUnregister::new(Arc::clone(&signaler), Arc::clone(event.handle()));
124
125        event.handle().state.register_signaler(pos, signaler)?;
126
127        Ok(auto_unregister)
128    }
129}
130
131impl Drop for AutoUnregister {
132    fn drop(&mut self) {
133        match self.handle.state.remove_signaler(&self.signaler) {
134            _ => {}
135        }
136    }
137}
138
139/// EventGuard
140///
141/// Simple RAII class to set an event and automatically clear it when it goes out of scope
142///
143/// # Examples
144///
145/// ```
146/// use win_events::{EventGuard, ManualResetEvent};///
147///
148/// let event = ManualResetEvent::new(false);///
149/// assert!(!event.is_set());///
150/// let event_guard = EventGuard::new(&event);
151/// assert!(event.is_set());
152/// drop(event_guard);
153/// assert!(!event.is_set());
154///
155/// ```
156pub struct EventGuard {
157    handle: Arc<EventHandle>,
158}
159
160impl EventGuard {
161    pub fn new(event: &dyn Event) -> EventGuard {
162        let handle = Arc::clone(event.handle());
163        handle.set();
164        EventGuard { handle }
165    }
166}
167
168impl Drop for EventGuard {
169    fn drop(&mut self) {
170        self.handle.clear()
171    }
172}
win_events/events/event.rs

win_events/events/
event.rs
