open-coroutine-core 0.7.0

The open-coroutine is a simple, efficient and generic 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

use std::ffi::{c_uint, c_void};
use std::time::Duration;
use windows_sys::Win32::Foundation::{BOOL, ERROR_TIMEOUT, FALSE, TRUE};
use crate::common::{get_timeout_time, now};
use crate::net::EventLoops;
use crate::syscall::reset_errno;
use crate::syscall::set_errno;

trait WaitOnAddressSyscall {
    extern "system" fn WaitOnAddress(
        &self,
        fn_ptr: Option<&extern "system" fn(*const c_void, *const c_void, usize, c_uint) -> BOOL>,
        address: *const c_void,
        compareaddress: *const c_void,
        addresssize: usize,
        dwmilliseconds: c_uint
    ) -> BOOL;
}

impl_syscall!(WaitOnAddressSyscallFacade, NioWaitOnAddressSyscall, RawWaitOnAddressSyscall,
    WaitOnAddress(
        address: *const c_void,
        compareaddress: *const c_void,
        addresssize: usize,
        dwmilliseconds: c_uint
    ) -> BOOL
);

impl_facade!(WaitOnAddressSyscallFacade, WaitOnAddressSyscall,
    WaitOnAddress(
        address: *const c_void,
        compareaddress: *const c_void,
        addresssize: usize,
        dwmilliseconds: c_uint
    ) -> BOOL
);

#[repr(C)]
#[derive(Debug, Default)]
struct NioWaitOnAddressSyscall<I: WaitOnAddressSyscall> {
    inner: I,
}

impl<I: WaitOnAddressSyscall> WaitOnAddressSyscall for NioWaitOnAddressSyscall<I> {
    extern "system" fn WaitOnAddress(
        &self,
        fn_ptr: Option<&extern "system" fn(*const c_void, *const c_void, usize, c_uint) -> BOOL>,
        address: *const c_void,
        compareaddress: *const c_void,
        addresssize: usize,
        dwmilliseconds: c_uint
    ) -> BOOL {
        let timeout = get_timeout_time(Duration::from_millis(dwmilliseconds.into()));
        loop {
            let mut left_time = timeout.saturating_sub(now());
            if 0 == left_time {
                set_errno(ERROR_TIMEOUT);
                return FALSE;
            }
            let r = self.inner.WaitOnAddress(
                fn_ptr,
                address,
                compareaddress,
                addresssize,
                (left_time / 1_000_000).min(1).try_into().expect("overflow"),
            );
            if TRUE == r {
                reset_errno();
                return r;
            }
            left_time = timeout.saturating_sub(now());
            if 0 == left_time {
                set_errno(ERROR_TIMEOUT);
                return FALSE;
            }
            let wait_time = if left_time > 10_000_000 {
                10_000_000
            } else {
                left_time
            };
            if EventLoops::wait_event(Some(Duration::new(
                wait_time / 1_000_000_000,
                (wait_time % 1_000_000_000) as _,
            )))
                .is_err()
            {
                return r;
            }
        }
    }
}

impl_raw!(RawWaitOnAddressSyscall, WaitOnAddressSyscall, windows_sys::Win32::System::Threading,
    WaitOnAddress(
        address: *const c_void,
        compareaddress: *const c_void,
        addresssize: usize,
        dwmilliseconds: c_uint
    ) -> BOOL
);