Struct RingBuffer 

pub struct RingBuffer<T, const S: usize>
where
    T: Default + Copy,
{ /* private fields */ }

Implementations

impl<T, const S: usize> RingBuffer<T, S>

where T: Default + Copy,

pub fn new() -> Self

Creates a new instance of RingBuffer with a fixed size.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();

Examples found in repository

examples/ex.rs (line 5)

fn main() {
    const SIZE: usize = 4096; // 4KB buffer
    let mut rb: RingBuffer<u32, SIZE> = RingBuffer::new();

    for i in 0..SIZE {
        rb.push(i as u32).unwrap();
    }
    println!("len={}", rb.len());

    let mut buffer = [0; 5];
    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);

    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);
    println!("len={}", rb.len());

    for _ in 0..rb.len() {
        rb.pop();
    }

    println!("is empty={}", rb.is_empty());
}

pub fn push(&mut self, item: T) -> Result<(), RingBufferError>

Pushes an item into the ring buffer. Returns an error if the buffer is full.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();
rb.push(42).unwrap();

Examples found in repository

examples/ex.rs (line 8)

fn main() {
    const SIZE: usize = 4096; // 4KB buffer
    let mut rb: RingBuffer<u32, SIZE> = RingBuffer::new();

    for i in 0..SIZE {
        rb.push(i as u32).unwrap();
    }
    println!("len={}", rb.len());

    let mut buffer = [0; 5];
    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);

    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);
    println!("len={}", rb.len());

    for _ in 0..rb.len() {
        rb.pop();
    }

    println!("is empty={}", rb.is_empty());
}

pub fn pop(&mut self) -> Option<T>

Pops an item from the ring buffer. Returns None if the buffer is empty.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();
rb.push(42).unwrap();
let item = rb.pop();
assert_eq!(item, Some(42));

Examples found in repository

examples/ex.rs (line 21)

fn main() {
    const SIZE: usize = 4096; // 4KB buffer
    let mut rb: RingBuffer<u32, SIZE> = RingBuffer::new();

    for i in 0..SIZE {
        rb.push(i as u32).unwrap();
    }
    println!("len={}", rb.len());

    let mut buffer = [0; 5];
    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);

    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);
    println!("len={}", rb.len());

    for _ in 0..rb.len() {
        rb.pop();
    }

    println!("is empty={}", rb.is_empty());
}

pub fn clear(&mut self)

Clears the ring buffer, resetting its state.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();
rb.push(42).unwrap();
rb.clear();
assert!(rb.is_empty());

pub fn pop_continuous(&mut self, count: usize) -> Result<usize, RingBufferError>

Pops a specified number of items from the ring buffer. Returns an error if the count exceeds the current length of the buffer.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();
rb.push(1).unwrap();
rb.push(2).unwrap();
let remaining_capacity = rb.pop_continuous(1).unwrap();
assert_eq!(remaining_capacity, 4095);

pub fn capacity(&self) -> usize

Returns the capacity of the ring buffer.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();
assert_eq!(rb.capacity(), 4096);

pub fn remaining_capacity(&self) -> usize

Returns the remaining capacity of the ring buffer.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();
assert_eq!(rb.remaining_capacity(), 4096);
rb.push(1).unwrap();
assert_eq!(rb.remaining_capacity(), 4095);

pub fn is_empty(&self) -> bool

Checks if the ring buffer is empty.

Examples found in repository

examples/ex.rs (line 24)

fn main() {
    const SIZE: usize = 4096; // 4KB buffer
    let mut rb: RingBuffer<u32, SIZE> = RingBuffer::new();

    for i in 0..SIZE {
        rb.push(i as u32).unwrap();
    }
    println!("len={}", rb.len());

    let mut buffer = [0; 5];
    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);

    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);
    println!("len={}", rb.len());

    for _ in 0..rb.len() {
        rb.pop();
    }

    println!("is empty={}", rb.is_empty());
}

pub fn is_full(&self) -> bool

Checks if the ring buffer is full.

pub fn len(&self) -> usize

Returns the current length of the ring buffer.

Examples found in repository

examples/ex.rs (line 10)

fn main() {
    const SIZE: usize = 4096; // 4KB buffer
    let mut rb: RingBuffer<u32, SIZE> = RingBuffer::new();

    for i in 0..SIZE {
        rb.push(i as u32).unwrap();
    }
    println!("len={}", rb.len());

    let mut buffer = [0; 5];
    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);

    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);
    println!("len={}", rb.len());

    for _ in 0..rb.len() {
        rb.pop();
    }

    println!("is empty={}", rb.is_empty());
}

pub fn write(&mut self, data: &[T]) -> Result<(), RingBufferError>

Writes a slice of data into the ring buffer. Returns an error if the buffer is full.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();
rb.write(&[1, 2, 3, 4]).unwrap();

pub fn read(&mut self, buffer: &mut [T]) -> usize

Reads data from the ring buffer into a provided mutable slice. Returns the number of items read. If the buffer has fewer items than the slice, it fills as many as possible.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();
rb.push(1).unwrap();
rb.push(2).unwrap();
let mut buffer = [0; 5];
let read_count = rb.read(&mut buffer);
assert_eq!(read_count, 2);
assert_eq!(&buffer[..read_count], &[1, 2]);

Examples found in repository

examples/ex.rs (line 13)

fn main() {
    const SIZE: usize = 4096; // 4KB buffer
    let mut rb: RingBuffer<u32, SIZE> = RingBuffer::new();

    for i in 0..SIZE {
        rb.push(i as u32).unwrap();
    }
    println!("len={}", rb.len());

    let mut buffer = [0; 5];
    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);

    let _ = rb.read(&mut buffer);
    println!("data={:?}", buffer);
    println!("len={}", rb.len());

    for _ in 0..rb.len() {
        rb.pop();
    }

    println!("is empty={}", rb.is_empty());
}

pub fn read_slice(&self, len: usize) -> Result<&[T], RingBufferError>

Reads a slice of data from the ring buffer. Returns an error if the requested length exceeds the current length of the buffer. If the data is contiguous, it returns a slice; otherwise, it returns an error.

use ring_buffer_no_std::RingBuffer;
let mut rb: RingBuffer<u32, 4096> = RingBuffer::new();
rb.push(1).unwrap();
rb.push(2).unwrap();
let slice = rb.read_slice(2).unwrap();
assert_eq!(slice, &[1, 2]);