spawn_groups 1.1.0

Structured concurrency construct written in Rust, for Rustaceans
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

use std::{
    mem::ManuallyDrop,
    sync::Arc,
    task::{RawWaker, RawWakerVTable, Waker},
};

use super::suspender::Suspender;

pub(crate) fn waker_helper(suspender: Arc<Suspender>) -> Waker {
    let raw: *const () = Arc::into_raw(suspender) as *const ();
    unsafe {
        Waker::from_raw(RawWaker::new(
            raw,
            &RawWakerVTable::new(clone_waker, wake, wake_by_ref, drop_waker),
        ))
    }
}

// clones the waker
pub(crate) unsafe fn clone_waker(ptr: *const ()) -> RawWaker {
    let ptr = ptr as *mut Suspender;
    let waker = ManuallyDrop::new(Arc::from_raw(ptr));
    let cloned = (*waker).clone();

    debug_assert_eq!(Arc::into_raw(ManuallyDrop::into_inner(waker)), ptr);

    let cloned_ptr = Arc::into_raw(cloned) as *const ();

    RawWaker::new(
        cloned_ptr,
        &RawWakerVTable::new(clone_waker, wake, wake_by_ref, drop_waker),
    )
}

// wakes up by consuming it
pub(crate) unsafe fn wake(ptr: *const ()) {
    Arc::from_raw(ptr as *mut Suspender).resume();
}

// wakes up by reference
pub(crate) unsafe fn wake_by_ref(ptr: *const ()) {
    let ptr = ptr as *mut Suspender;

    let waker = ManuallyDrop::new(Arc::from_raw(ptr));
    waker.resume();

    debug_assert_eq!(Arc::into_raw(ManuallyDrop::into_inner(waker)), ptr);
}

// drops the waker
pub(crate) unsafe fn drop_waker(ptr: *const ()) {
    _ = Arc::from_raw(ptr as *mut Suspender);
}