-
Notifications
You must be signed in to change notification settings - Fork 605
/
waker_ref.rs
70 lines (63 loc) · 2.04 KB
/
waker_ref.rs
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 super::arc_wake::{ArcWake};
use super::waker::waker_vtable;
use alloc::sync::Arc;
use core::mem::ManuallyDrop;
use core::marker::PhantomData;
use core::ops::Deref;
use core::task::{Waker, RawWaker};
/// A [`Waker`] that is only valid for a given lifetime.
///
/// Note: this type implements [`Deref<Target = Waker>`](std::ops::Deref),
/// so it can be used to get a `&Waker`.
#[derive(Debug)]
pub struct WakerRef<'a> {
waker: ManuallyDrop<Waker>,
_marker: PhantomData<&'a ()>,
}
impl<'a> WakerRef<'a> {
/// Create a new [`WakerRef`] from a [`Waker`] reference.
pub fn new(waker: &'a Waker) -> Self {
// copy the underlying (raw) waker without calling a clone,
// as we won't call Waker::drop either.
let waker = ManuallyDrop::new(unsafe { core::ptr::read(waker) });
WakerRef {
waker,
_marker: PhantomData,
}
}
/// Create a new [`WakerRef`] from a [`Waker`] that must not be dropped.
///
/// Note: this if for rare cases where the caller created a [`Waker`] in
/// an unsafe way (that will be valid only for a lifetime to be determined
/// by the caller), and the [`Waker`] doesn't need to or must not be
/// destroyed.
pub fn new_unowned(waker: ManuallyDrop<Waker>) -> Self {
WakerRef {
waker,
_marker: PhantomData,
}
}
}
impl Deref for WakerRef<'_> {
type Target = Waker;
fn deref(&self) -> &Waker {
&self.waker
}
}
/// Creates a reference to a [`Waker`] from a reference to `Arc<impl ArcWake>`.
///
/// The resulting [`Waker`] will call
/// [`ArcWake.wake()`](ArcWake::wake) if awoken.
#[inline]
pub fn waker_ref<W>(wake: &Arc<W>) -> WakerRef<'_>
where
W: ArcWake
{
// simply copy the pointer instead of using Arc::into_raw,
// as we don't actually keep a refcount by using ManuallyDrop.<
let ptr = (&**wake as *const W) as *const ();
let waker = ManuallyDrop::new(unsafe {
Waker::from_raw(RawWaker::new(ptr, waker_vtable::<W>()))
});
WakerRef::new_unowned(waker)
}