maf 0.1.0-alpha.6

MAF is an authoritative realtime framework for writing simple, secure, and scalable apps.
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
71
72
73
74
75

use std::{
    rc::Rc,
    task::{RawWaker, RawWakerVTable, Waker},
};

use super::{task::TaskId, Runtime};

struct WakerData {
    runtime: Runtime,
    task_id: TaskId,
}

impl WakerData {
    pub unsafe fn from_raw(raw: *const ()) -> Rc<Self> {
        Rc::from_raw(raw as *const Self)
    }
}

fn create_raw_waker(data: Rc<WakerData>) -> RawWaker {
    RawWaker::new(
        Rc::into_raw(data) as *const (),
        &RawWakerVTable::new(
            clone_callback,
            wake_callback,
            wake_by_ref_callback,
            drop_callback,
        ),
    )
}

pub(super) fn create_waker(runtime: Runtime, task_id: TaskId) -> Waker {
    let data = Rc::new(WakerData { runtime, task_id });
    let waker = unsafe { Waker::from_raw(create_raw_waker(data)) };
    waker
}

unsafe fn clone_callback(ptr: *const ()) -> RawWaker {
    let rc = WakerData::from_raw(ptr);
    let clone = Rc::clone(&rc);

    std::mem::forget(rc);
    RawWaker::new(
        Rc::into_raw(clone) as *const (),
        &RawWakerVTable::new(
            clone_callback,
            wake_callback,
            wake_by_ref_callback,
            drop_callback,
        ),
    )
}

unsafe fn wake_callback(ptr: *const ()) {
    let rc = WakerData::from_raw(ptr);

    rc.runtime
        .resume_task(rc.task_id)
        .expect("error polling task");

    std::mem::forget(rc);
}

unsafe fn wake_by_ref_callback(ptr: *const ()) {
    let rc = WakerData::from_raw(ptr);

    rc.runtime
        .resume_task(rc.task_id)
        .expect("error polling task");

    std::mem::forget(rc);
}

unsafe fn drop_callback(ptr: *const ()) {
    drop(WakerData::from_raw(ptr));
}