pinned 0.1.0

Synchronisation primitives for !Send tasks.
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

//! A Waker collection.
//!
//! We need to wake all pending tasks as the task is not guaranteed that they are being actively
//! polled / already cancelled.

use std::task::Waker;

use crate::cell::UnsafeCell;

#[derive(Debug, Clone)]
pub(super) struct WakeGuard<'a> {
    wakers: &'a Wakers,
}

impl Drop for WakeGuard<'_> {
    fn drop(&mut self) {
        self.wakers.wake_all();
    }
}

#[derive(Debug)]
pub(super) struct Wakers {
    inner: UnsafeCell<Vec<Waker>>,
}

impl Wakers {
    pub fn new() -> Self {
        Self {
            inner: UnsafeCell::new(Vec::new()),
        }
    }

    pub fn push(&self, w: Waker) {
        // SAFETY:
        //
        // We can acquire a mutable reference without checking as:
        //
        // - This type is !Sync and !Send.
        // - This function is not used by any other functions and hence uniquely owns the
        // mutable reference.
        // - The mutable reference is dropped at the end of this function.
        unsafe {
            self.inner.with_mut(move |inner| inner.push(w));
        }
    }

    pub fn wake_guard(&self) -> WakeGuard<'_> {
        WakeGuard { wakers: self }
    }

    pub fn wake_all(&self) {
        // SAFETY:
        //
        // We can acquire a mutable reference without checking as:
        //
        // - This type is !Sync and !Send.
        // - This function is not used by any other functions and hence uniquely owns the
        // mutable reference.
        // - The mutable reference is dropped at the end of this function.
        unsafe {
            self.inner.with_mut(|inner| {
                for waker in inner.drain(..) {
                    waker.wake()
                }
            });
        }
    }
}