use-event-stream 0.1.0

#![forbid(unsafe_code)]
#![doc = include_str!("../README.md")]

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct EventStream<E> {
    events: Vec<E>,
}

impl<E> EventStream<E> {
    pub const fn new() -> Self {
        Self { events: Vec::new() }
    }

    pub const fn from_events(events: Vec<E>) -> Self {
        Self { events }
    }

    pub fn push(&mut self, event: E) {
        self.events.push(event);
    }

    pub fn iter(&self) -> core::slice::Iter<'_, E> {
        self.events.iter()
    }

    pub fn len(&self) -> usize {
        self.events.len()
    }

    pub fn is_empty(&self) -> bool {
        self.events.is_empty()
    }
}

impl<'a, E> IntoIterator for &'a EventStream<E> {
    type Item = &'a E;
    type IntoIter = core::slice::Iter<'a, E>;

    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

#[cfg(test)]
mod tests {
    use super::EventStream;

    #[test]
    fn pushes_and_iterates_events() {
        let mut stream = EventStream::new();
        stream.push("command.started");
        stream.push("command.finished");

        let events = stream.iter().copied().collect::<Vec<_>>();

        assert_eq!(events, ["command.started", "command.finished"]);
        assert_eq!(stream.len(), 2);
    }

    #[test]
    fn builds_from_existing_events() {
        let stream = EventStream::from_events(vec!["a", "b"]);

        assert!(!stream.is_empty());
        assert_eq!(stream.len(), 2);
    }
}