liblightning 0.0.2

High-performance general-purpose stackful coroutine library.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::cell::UnsafeCell;
use co::{CommonCoState, SendableCoState};
use scheduler::{SharedSchedState, SyncSchedState};
use invoke_box::OnceInvokeBox;

pub enum PromiseState {
    Waiting(OnceInvokeBox<NotifyHandle, ()>),
    Started // running / terminated
}

/// Promises act as an async "primitive" that does not carry data.
pub struct Promise {
    // TODO: change to Cell
    state: UnsafeCell<PromiseState>
}

pub struct PromiseBegin {
    target: OnceInvokeBox<NotifyHandle, ()>
}

pub struct NotifyHandle {
    sched_state: SharedSchedState,
    co: Box<CommonCoState>
}

pub struct SendableNotifyHandle {
    sched_state: SyncSchedState,
    co: SendableCoState
}

impl NotifyHandle {
    pub(crate) fn new(s: SharedSchedState, co: Box<CommonCoState>) -> NotifyHandle {
        NotifyHandle {
            sched_state: s,
            co: co
        }
    }

    pub fn notify(self) {
        self.sched_state.push_coroutine_raw(self.co);
    }

    pub fn into_sendable(self) -> SendableNotifyHandle {
        SendableNotifyHandle {
            sched_state: self.sched_state.get_sync(),
            co: SendableCoState::new(self.co)
        }
    }
}

impl SendableNotifyHandle {
    // TODO: Is this correct?
    pub fn notify(self) {
        // Safe as long as we've made sure that the coroutine originally
        // belongs to the sched_state
        unsafe {
            self.sched_state.add_coroutine(self.co);
        }
    }

    fn _assert_sendable(self) {
        let _: Box<Send> = Box::new(self);
    }
}

impl PromiseBegin {
    pub fn run(self, cb: NotifyHandle) {
        self.target.call(cb)
    }
}

impl Promise {
    pub fn new<F: FnOnce(NotifyHandle) + 'static>(f: F) -> Promise {
        Promise {
            state: UnsafeCell::new(PromiseState::Waiting(
                OnceInvokeBox::new(f)
            ))
        }
    }

    pub fn new_started() -> Promise {
        Promise {
            state: UnsafeCell::new(PromiseState::Started)
        }
    }

    pub fn is_started(&self) -> bool {
        let state = unsafe { &mut *self.state.get() };
        match *state {
            PromiseState::Waiting(_) => false,
            PromiseState::Started => true
        }
    }

    pub fn build_begin(&self) -> PromiseBegin {
        let state = unsafe { &mut *self.state.get() };
        match *state {
            PromiseState::Waiting(_) => {},
            _ => panic!("Attempting to call begin() on an already started promise")
        }
        if let PromiseState::Waiting(t) = ::std::mem::replace(state, PromiseState::Started) {
            PromiseBegin {
                target: t
            }
        } else {
            unreachable!()
        }
    }
}