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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
use std::{cell::RefCell, rc::Rc};

use crate::{Poll, Readiness, Token};

pub mod channel;
pub mod generic;
pub mod ping;
#[cfg(target_os = "linux")]
pub mod signals;
pub mod timer;

/// Trait representing an event source
///
/// This is the trait you need to implement if you wish to create your own
/// calloop-compatible event sources.
///
/// The 3 type parameter define the type of closure the user will need to
/// provide to process events for your event source.
///
/// The `process_events` method will be called when one of the FD you registered
/// is ready, with the associated readiness and token.
///
/// The last 3 methods are plumbing to let your source register itself with the
/// polling system. See their documentation for details.
pub trait EventSource {
    /// The type of events generated by your source.
    type Event;
    /// Some metadata of your event source
    ///
    /// This is typically useful if your source contains some internal state that
    /// the user may need to interact with when processing events. The user callback
    /// will receive a `&mut Metadata` reference.
    ///
    /// Just set to `()` if not needed.
    type Metadata;
    /// The return type of the user callback
    ///
    /// If the user needs to return some value back to your event source once its
    /// processing is finshed (to indicate success or failure for example), you can
    /// specify it using this type.
    ///
    /// Just set to `()` if not needed.
    type Ret;

    /// Process any relevant events
    ///
    /// This method will be called every time one of the FD you registered becomes
    /// ready, including the readiness details and the associated token.
    ///
    /// Your event source will then do some processing of the file descriptor(s) to generate
    /// events, and call the provided `callback` for each one of them.
    ///
    /// You should ensure you drained the file descriptors of their events, especially if using
    /// edge-triggered mode.
    fn process_events<F>(
        &mut self,
        readiness: Readiness,
        token: Token,
        callback: F,
    ) -> std::io::Result<()>
    where
        F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret;

    /// Register yourself to this poll instance
    ///
    /// You should register all your relevant file descriptors to the provided `Poll`
    /// using its `Poll::register` method.
    ///
    /// If you need to register more than one file descriptor, you can change the
    /// `sub_id` field of the `Token` to differentiate between them.
    fn register(&mut self, poll: &mut Poll, token: Token) -> std::io::Result<()>;

    /// Re-register your file descriptors
    ///
    /// Your should update the registration of all your relevant file descriptor to
    /// the provided `Poll` using its `Poll::reregister`, if necessary.
    fn reregister(&mut self, poll: &mut Poll, token: Token) -> std::io::Result<()>;

    /// Unregister your file descriptors
    ///
    /// You should unregister all your file descriptors from this `Poll` using its
    /// `Poll::unregister` method.
    fn unregister(&mut self, poll: &mut Poll) -> std::io::Result<()>;
}

pub(crate) struct Dispatcher<S, F> {
    source: S,
    callback: F,
}

impl<S, F> Dispatcher<S, F> {
    pub fn new(source: S, callback: F) -> Self {
        Dispatcher { source, callback }
    }
}

impl<Data, S, F> EventDispatcher<Data> for RefCell<Dispatcher<S, F>>
where
    S: EventSource + 'static,
    F: FnMut(S::Event, &mut S::Metadata, &mut Data) -> S::Ret,
{
    fn process_events(
        &self,
        readiness: Readiness,
        token: Token,
        data: &mut Data,
    ) -> std::io::Result<()> {
        let mut disp = self.borrow_mut();
        let Dispatcher {
            ref mut source,
            ref mut callback,
            ..
        } = *disp;
        source.process_events(readiness, token, |event, meta| callback(event, meta, data))
    }

    fn register(&self, poll: &mut Poll, token: Token) -> std::io::Result<()> {
        self.borrow_mut().source.register(poll, token)
    }

    fn reregister(&self, poll: &mut Poll, token: Token) -> std::io::Result<()> {
        self.borrow_mut().source.reregister(poll, token)
    }

    fn unregister(&self, poll: &mut Poll) -> std::io::Result<()> {
        self.borrow_mut().source.unregister(poll)
    }

    fn as_source_any(&self) -> std::cell::RefMut<dyn std::any::Any> {
        std::cell::RefMut::map(self.borrow_mut(), |disp| &mut disp.source)
    }

    fn into_source_any(self: Rc<Self>) -> Box<dyn std::any::Any> {
        let me = Rc::try_unwrap(self).unwrap_or_else(|_| panic!("Unwrapping a shared source."));
        Box::new(me.into_inner().source)
    }
}

pub(crate) trait EventDispatcher<Data> {
    fn process_events(
        &self,
        readiness: Readiness,
        token: Token,
        data: &mut Data,
    ) -> std::io::Result<()>;

    fn register(&self, poll: &mut Poll, token: Token) -> std::io::Result<()>;

    fn reregister(&self, poll: &mut Poll, token: Token) -> std::io::Result<()>;

    fn unregister(&self, poll: &mut Poll) -> std::io::Result<()>;

    fn as_source_any(&self) -> std::cell::RefMut<dyn std::any::Any>;

    fn into_source_any(self: Rc<Self>) -> Box<dyn std::any::Any>;
}

/// A token representing an event source inserted in the event loop
///
/// You'll need it to interact with your source via `LoopHandle`
pub struct Source<S: EventSource> {
    pub(crate) token: Token,
    pub(crate) _type: std::marker::PhantomData<*const S>,
}

/// An idle callback that was inserted in this loop
///
/// This handle allows you to cancel the callback. Dropping
/// it will *not* cancel it.
pub struct Idle {
    pub(crate) callback: Rc<RefCell<dyn CancellableIdle>>,
}

impl Idle {
    /// Cancel the idle callback if it was not already run
    pub fn cancel(self) {
        self.callback.borrow_mut().cancel();
    }
}

pub(crate) trait CancellableIdle {
    fn cancel(&mut self);
}

impl<F> CancellableIdle for Option<F> {
    fn cancel(&mut self) {
        self.take();
    }
}

pub(crate) trait IdleDispatcher<Data> {
    fn dispatch(&mut self, data: &mut Data);
}

impl<Data, F> IdleDispatcher<Data> for Option<F>
where
    F: FnMut(&mut Data),
{
    fn dispatch(&mut self, data: &mut Data) {
        if let Some(callabck) = self.as_mut() {
            callabck(data);
        }
    }
}