calloop 0.3.1

A callback-based event loop
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::cell::RefCell;
use std::io;
use std::rc::Rc;

use mio::{Evented, Poll, PollOpt, Ready, Token};

use list::ErasedList;

pub mod channel;
pub mod generic;
#[cfg(unix)]
pub mod signals;
pub mod timer;

/// Trait representing a source that can be inserted into an EventLoop
///
/// This is the interface between the source and the loop, you need to
/// implement it to use your custom event sources.
pub trait EventSource: Evented {
    /// The type of events generated by your sources
    type Event;

    /// The interest value that will be given to `mio` when registering your source
    fn interest(&self) -> Ready;

    /// The pollopt value that will be given to `mio` when registering your source
    fn pollopts(&self) -> PollOpt;

    /// Wrap an user callback into a dispatcher, that will convert an `mio` readiness
    /// into an event
    fn make_dispatcher<Data: 'static, F: FnMut(Self::Event, &mut Data) + 'static>(
        &self,
        callback: F,
    ) -> Rc<RefCell<EventDispatcher<Data>>>;
}

/// An event dispatcher
///
/// It is the junction between user callbacks and and an event source,
/// receiving `mio` readinesses, converting them into appropriate events
/// and calling their inner user callback.
pub trait EventDispatcher<Data> {
    /// The source has a readiness event
    fn ready(&mut self, ready: Ready, data: &mut Data);
}

/// An event source that has been inserted into the event loop
///
/// This handle allows you to remove it, and possibly more interactions
/// depending on the source kind that will be provided by the `Deref`
/// implementation of this struct to the evented object.
///
/// Dropping this handle does not deregister this source from the event loop,
/// but will drop the wrapped `EventSource`, maybe rendering it inert depending on
/// its implementation.
pub struct Source<E: EventSource> {
    pub(crate) source: E,
    pub(crate) poll: Rc<Poll>,
    pub(crate) list: Rc<RefCell<ErasedList>>,
    pub(crate) token: Token,
}

impl<E: EventSource> Source<E> {
    /// Refresh the registration of this event source to the loop
    ///
    /// This can be necessary if the evented object provides methods to change
    /// its behavior. Its documentation should inform you of the need for re-registration.
    pub fn reregister(&self) -> io::Result<()> {
        self.poll.reregister(
            &self.source,
            self.token,
            self.source.interest(),
            self.source.pollopts(),
        )
    }

    /// Remove this source from the event loop
    ///
    /// You are given the evented object back.
    pub fn remove(self) -> E {
        let _ = self.poll.deregister(&self.source);
        let _dispatcher = self.list.borrow_mut().del_source(self.token);
        self.source
    }
}

impl<E: EventSource> ::std::ops::Deref for Source<E> {
    type Target = E;
    fn deref(&self) -> &E {
        &self.source
    }
}

impl<E: EventSource> ::std::ops::DerefMut for Source<E> {
    fn deref_mut(&mut self) -> &mut E {
        &mut self.source
    }
}

/// 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<ErasedIdle>>,
}

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

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

impl<Data> ErasedIdle for Option<Box<FnMut(&mut Data)>> {
    fn cancel(&mut self) {
        self.take();
    }
}