river-ring-buffer 1.0.0

use std::fmt;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BufferFullError;

impl fmt::Display for BufferFullError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Buffer full")
    }
}

type Result<T> = std::result::Result<T, BufferFullError>;

pub struct RingBuffer<T> {
    buffer: Vec<T>,
    write_index: usize,
    read_index: usize,
    capacity: usize,
}

impl<T> RingBuffer<T>
where
    T: Default,
    T: Copy,
{
    /// Create a new ring buffer with the given capacity
    pub fn new(capacity: usize) -> Self {
        RingBuffer {
            capacity: capacity + 1,
            buffer: vec![T::default(); capacity + 1],
            write_index: 0,
            read_index: 0,
        }
    }

    /// Read a value from the buffer
    ///
    /// Returns `None` if the buffer is empty.
    pub fn read(&mut self) -> Option<T> {
        if self.read_index == self.write_index {
            return None;
        }

        let value = self.buffer[self.read_index];
        self.read_index = (self.read_index + 1) % self.buffer.len();

        Some(value)
    }

    /// Write a value to the buffer
    ///
    /// If the buffer is full an error is returned.
    pub fn put(&mut self, arg: T) -> Result<()> {
        if (self.write_index + 1) % self.capacity == self.read_index {
            return Err(BufferFullError);
        }

        self.buffer[self.write_index] = arg;
        self.write_index = (self.write_index + 1) % self.capacity;
        Ok(())
    }
}

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

    #[test]
    fn it_returns_none_when_ring_buffer_empty() {
        let mut buffer: RingBuffer<i32> = RingBuffer::new(10); // Allocate a new ring buffer with capacity 10

        assert_eq!(None, buffer.read()); // Read from the buffer
    }

    #[test]
    fn it_returns_values_in_fifo_order() -> Result<()> {
        let mut buffer = RingBuffer::new(10);

        buffer.put(1)?;
        buffer.put(2)?;
        buffer.put(3)?;
        buffer.put(4)?;
        buffer.put(5)?;

        assert_eq!(Some(1), buffer.read());
        assert_eq!(Some(2), buffer.read());
        assert_eq!(Some(3), buffer.read());
        assert_eq!(Some(4), buffer.read());
        assert_eq!(Some(5), buffer.read());

        Ok(())
    }

    #[test]
    fn it_returns_error_when_buffer_is_full() {
        let mut buffer = RingBuffer::new(3);

        buffer.put(1).unwrap();
        buffer.put(2).unwrap();
        buffer.put(3).unwrap();

        assert_eq!(Err(BufferFullError), buffer.put(4));
    }

    #[test]
    fn it_overwrites_oldest_value_when_buffer_is_full() -> Result<()> {
        let mut buffer = RingBuffer::new(3);

        buffer.put(1)?;
        buffer.put(2)?;
        buffer.put(3)?;

        assert_eq!(Some(1), buffer.read());

        buffer.put(4)?;

        assert_eq!(Some(2), buffer.read());
        assert_eq!(Some(3), buffer.read());
        assert_eq!(Some(4), buffer.read());

        Ok(())
    }
}