win-events 0.0.2

A poor attempt to implement WaitForMultipleObjects and the ManualReset, AutoReset and Pulse types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::collections::LinkedList;
use std::error::Error;
use std::sync::{Arc, Condvar, Mutex, MutexGuard};

/// Wait info that gets registered with an EventState, with the position of the Event in a given
/// Vec<dyn Event> used in one of the wait functions
#[derive(Clone)]
pub(crate) struct WaitInfo {
    pub(crate) pos: usize,
    pub(crate) signaler: Arc<dyn Signaler>,
}

/// Trait for abstracting a signaler for a constructed wait object
pub(crate) trait Signaler: Send + Sync {
    fn fire(&self, pos: usize) -> Result<(), Box<dyn Error>>;
    fn clear(&self, pos: usize) -> Result<(), Box<dyn Error>>;
}

pub(crate) struct Waiter<Data> {
    d: Mutex<Data>,
    pub(crate) condvar: Condvar,
}

impl<Data> Waiter<Data> {
    pub(crate) fn new(d: Data) -> Waiter<Data> {
        Waiter {
            d: Mutex::new(d),
            condvar: Condvar::new(),
        }
    }

    pub(crate) fn lock(&self) -> Result<MutexGuard<Data>, Box<dyn Error>> {
        let lock = self.d.lock();
        match lock {
            Ok(data) => Ok(data),
            Err(error) => {
                return Err(format!("Failed to grab wait mutex: {}", error).into());
            }
        }
    }
}

pub(crate) struct WaitList {
    waiters: Mutex<LinkedList<WaitInfo>>,
}

impl WaitList {
    pub(crate) fn new() -> WaitList {
        WaitList {
            waiters: Mutex::new(LinkedList::new()),
        }
    }

    pub(crate) fn fire(&self) {
        let result = self.waiters.lock();
        let waiters = match result {
            Ok(waiters) => waiters,
            Err(_) => return,
        };

        for waiter in waiters.iter() {
            let result = waiter.signaler.fire(waiter.pos);
            match result {
                Ok(_) => {}
                Err(_) => {}
            }
        }
    }

    pub(crate) fn clear(&self) {
        let result = self.waiters.lock();
        let waiters = match result {
            Ok(waiters) => waiters,
            Err(_) => return,
        };

        for waiter in waiters.iter() {
            let result = waiter.signaler.clear(waiter.pos);
            match result {
                Ok(_) => {}
                Err(_) => {}
            }
        }
    }

    pub(crate) fn register_signaler(
        &self,
        pos: usize,
        signaler: Arc<dyn Signaler>,
    ) -> Result<(), Box<dyn Error>> {
        let result = self.waiters.lock();

        match result {
            Ok(mut waiters) => {
                waiters.push_back(WaitInfo { pos, signaler });
                Ok(())
            }
            Err(error) => Err(format!("Could not grab registered waiters lock {}", error).into()),
        }
    }

    pub(crate) fn remove_signaler(
        &self,
        signaler: &Arc<dyn Signaler>,
    ) -> Result<(), Box<dyn Error>> {
        let result = self.waiters.lock();

        match result {
            Ok(mut waiters) => {
                *waiters = {
                    let list = waiters.clone();
                    let iter = list.into_iter();
                    let filtered = iter.filter(|info| Arc::ptr_eq(&info.signaler, signaler));
                    filtered.collect()
                };
                Ok(())
            }
            Err(error) => Err(format!("Could not grab registered waiters lock {}", error).into()),
        }
    }
}