evering 0.1.0

Typed shared-memory communication across processes
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

use std::{
    io,
    os::windows::io::{
        AsHandle, AsRawHandle, BorrowedHandle, IntoRawHandle, OwnedHandle, RawHandle,
    },
    sync::Arc,
};

use windows_sys::Win32::{
    Foundation::{CloseHandle, HANDLE},
    System::Threading::{CreateEventW, ResetEvent, SetEvent},
};

use crate::notify::Notify;

#[derive(Debug)]
struct Handle(HANDLE);

// A kernel handle can be used concurrently by SetEvent, ResetEvent, and wait
// registration until the last local owner closes it.
unsafe impl Send for Handle {}
unsafe impl Sync for Handle {}

impl Drop for Handle {
    fn drop(&mut self) {
        unsafe {
            CloseHandle(self.0);
        }
    }
}

#[derive(Clone, Debug)]
pub struct Ring(Arc<Handle>);

#[derive(Clone, Debug)]
pub struct Event(Arc<Handle>);

/// Creates the two local owners of one sticky manual-reset event.
pub fn event() -> io::Result<(Ring, Event)> {
    let handle = unsafe { CreateEventW(core::ptr::null(), 1, 0, core::ptr::null()) };
    if handle.is_null() {
        return Err(io::Error::last_os_error());
    }
    let handle = Arc::new(Handle(handle));
    Ok((Ring(handle.clone()), Event(handle)))
}

impl Notify for Ring {
    type Error = io::Error;

    fn notify(&self) -> Result<(), Self::Error> {
        if unsafe { SetEvent(self.0.0) } == 0 {
            Err(io::Error::last_os_error())
        } else {
            Ok(())
        }
    }
}

impl Ring {
    /// Takes ownership of a received notification handle.
    pub fn from_owned_handle(handle: OwnedHandle) -> Self {
        Self(Arc::new(Handle(handle.into_raw_handle().cast())))
    }
}

impl Event {
    /// Takes ownership of a received wait handle.
    pub fn from_owned_handle(handle: OwnedHandle) -> Self {
        Self(Arc::new(Handle(handle.into_raw_handle().cast())))
    }

    pub(crate) fn clear(&self) -> io::Result<()> {
        if unsafe { ResetEvent(self.0.0) } == 0 {
            Err(io::Error::last_os_error())
        } else {
            Ok(())
        }
    }

    pub(crate) fn handle(&self) -> HANDLE {
        self.0.0
    }
}

impl AsRawHandle for Event {
    fn as_raw_handle(&self) -> RawHandle {
        self.0.0.cast()
    }
}

impl AsRawHandle for Ring {
    fn as_raw_handle(&self) -> RawHandle {
        self.0.0.cast()
    }
}

impl AsHandle for Event {
    fn as_handle(&self) -> BorrowedHandle<'_> {
        unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }
    }
}

impl AsHandle for Ring {
    fn as_handle(&self) -> BorrowedHandle<'_> {
        unsafe { BorrowedHandle::borrow_raw(self.as_raw_handle()) }
    }
}