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
101
102
103

use crate::common::CondvarBlocker;
use crossbeam_utils::atomic::AtomicCell;
use mio::event::Event;
use mio::unix::SourceFd;
use mio::{Events, Interest, Poll, Token};
use std::ffi::c_int;
use std::ops::Deref;
use std::sync::atomic::AtomicBool;
use std::time::Duration;

impl super::Interest for Interest {
    fn read(_: usize) -> Self {
        Interest::READABLE
    }

    fn write(_: usize) -> Self {
        Interest::WRITABLE
    }

    fn read_and_write(_: usize) -> Self {
        Interest::READABLE.add(Interest::WRITABLE)
    }
}

impl super::Event for Event {
    fn get_token(&self) -> usize {
        self.token().0
    }

    fn readable(&self) -> bool {
        self.is_readable()
    }

    fn writable(&self) -> bool {
        self.is_writable()
    }
}

impl super::EventIterator<Event> for Events {
    fn iterator<'a>(&'a self) -> impl Iterator<Item = &'a Event>
    where
        Event: 'a,
    {
        self.iter()
    }
}

#[repr(C)]
#[derive(educe::Educe)]
#[educe(Debug)]
pub(crate) struct Poller {
    waiting: AtomicBool,
    blocker: CondvarBlocker,
    #[educe(Debug(ignore))]
    inner: AtomicCell<Poll>,
}

impl Poller {
    pub(crate) fn new() -> std::io::Result<Self> {
        Ok(Self {
            waiting: AtomicBool::new(false),
            blocker: CondvarBlocker::default(),
            inner: AtomicCell::new(Poll::new()?),
        })
    }
}

impl Deref for Poller {
    type Target = Poll;

    fn deref(&self) -> &Self::Target {
        unsafe { &*self.inner.as_ptr() }
    }
}

impl super::Selector<Interest, Event, Events> for Poller {
    fn waiting(&self) -> &AtomicBool {
        &self.waiting
    }

    fn blocker(&self) -> &CondvarBlocker {
        &self.blocker
    }

    fn do_select(&self, events: &mut Events, timeout: Option<Duration>) -> std::io::Result<()> {
        let inner = unsafe { &mut *self.inner.as_ptr() };
        inner.poll(events, timeout)
    }

    fn do_register(&self, fd: c_int, token: usize, interests: Interest) -> std::io::Result<()> {
        self.registry()
            .register(&mut SourceFd(&fd), Token(token), interests)
    }

    fn do_reregister(&self, fd: c_int, token: usize, interests: Interest) -> std::io::Result<()> {
        self.registry()
            .reregister(&mut SourceFd(&fd), Token(token), interests)
    }

    fn do_deregister(&self, fd: c_int, _: usize) -> std::io::Result<()> {
        self.registry().deregister(&mut SourceFd(&fd))
    }
}