Skip to main content

gaea/
user_space.rs

1//! Module with user space readiness event queue.
2
3#[cfg(all(not(feature = "std"), feature = "user_space"))]
4use alloc::vec::Vec;
5
6use core::time::Duration;
7
8use log::trace;
9
10use crate::event::{self, Event};
11
12/// User space readiness queue.
13///
14/// A simple, single threaded user space readiness event queue. This implements
15/// [`event::Source`] which can be used to poll for readiness events.
16///
17/// Polling this event source never returns an error.
18///
19/// # Examples
20///
21/// ```
22/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
23/// use gaea::{Event, Queue, Ready, event, poll};
24///
25/// let mut queue = Queue::new();
26/// let mut events = Vec::new();
27///
28/// // Add a new event.
29/// let event = Event::new(event::Id(0), Ready::READABLE);
30/// queue.add(event);
31///
32/// // Now we poll for events. Note that this is safe to unwrap as polling
33/// // `Queue` never returns an error.
34/// poll::<_, ()>(&mut [&mut queue], &mut events, None).unwrap();
35///
36/// assert_eq!(events.get(0), Some(&event));
37/// #     Ok(())
38/// # }
39/// ```
40#[derive(Debug)]
41pub struct Queue {
42    events: Vec<Event>,
43}
44
45impl Queue {
46    /// Create a new user space readiness event queue.
47    pub fn new() -> Queue {
48        Queue {
49            events: Vec::new(),
50        }
51    }
52
53    /// Add a new readiness event.
54    pub fn add(&mut self, event: Event) {
55        trace!("adding user space event: id={}, readiness={:?}",
56            event.id(), event.readiness());
57        self.events.push(event);
58    }
59}
60
61impl<ES, E> event::Source<ES, E> for Queue
62    where ES: event::Sink,
63{
64    fn max_timeout(&self) -> Option<Duration> {
65        if !self.events.is_empty() {
66            Some(Duration::from_millis(0))
67        } else {
68            None
69        }
70    }
71
72    fn poll(&mut self, event_sink: &mut ES) -> Result<(), E> {
73        trace!("polling user space events");
74        let drain = self.events.drain(..event_sink.capacity_left().min(self.events.len()));
75        event_sink.extend(drain);
76        Ok(())
77    }
78}
79
80impl Default for Queue {
81    fn default() -> Queue {
82        Queue::new()
83    }
84}