sem_safe 0.2.1

Safe usage of POSIX Semaphores (`sem_post`, `sem_wait`, etc).
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

use crate::UnwrapOS as _;
use cfg_if::cfg_if;
use sem_safe::SemaphoreRef;

cfg_if! { if #[cfg(feature = "plaster")] {
    use sem_safe::plaster::non_named::Semaphore;
} else if #[cfg(all(feature = "unnamed", not(target_os = "macos")))] {
    use sem_safe::unnamed::Semaphore;
} else if #[cfg(feature = "anonymous")] {
    use sem_safe::anonymous::Semaphore;
} else if #[cfg(feature = "named")] {
    use sem_safe::named::Semaphore;
} }


fn a_sem_ref<const B: bool>() -> (SemaphoreRef<'static>, Option<impl FnOnce()>) {
    cfg_if! { if #[cfg(any(feature = "plaster",
                           all(feature = "unnamed", not(target_os = "macos")),
                           feature = "anonymous"))] {
        use core::pin::Pin;
        use sem_safe::non_named::Semaphore as _;

        let sem = Pin::static_ref(if B {
            static SEM: Semaphore = Semaphore::uninit();
            &SEM
        } else {
            static SEM: Semaphore = Semaphore::uninit();
            &SEM
        });
        (sem.init().unwrap_os(), None::<fn()>)
    }
    else if #[cfg(feature = "named")] {
        use crate::name;
        use sem_safe::named::OpenFlags;
        use std::sync::OnceLock;

        let (sem, name) = if B {
            static SEM: OnceLock<Semaphore> = OnceLock::new();
            (&SEM, name("refs-1"))
        } else {
            static SEM: OnceLock<Semaphore> = OnceLock::new();
            (&SEM, name("refs-2"))
        };
        let sem = sem.get_or_init(
            || Semaphore::open(&name, OpenFlags::Create {
                exclusive: true,
                mode: 0o600,
                value: 0
            }).unwrap_os());
        (sem.sem_ref(), Some(move || Semaphore::unlink(&name).unwrap_os()))
    } }
}


#[test]
fn eq() {
    let (sr1, f1) = a_sem_ref::<true>();
    let (sr2, f2) = a_sem_ref::<false>();
    assert_eq!(sr1, sr1);
    assert_ne!(sr1, sr2);
    assert_eq!(sr2, sr2);
    assert_ne!(sr2, sr1);

    if let Some(unlink_name) = f1 {
        unlink_name();
    }
    if let Some(unlink_name) = f2 {
        unlink_name();
    }
}