Struct RotatingBuffer

pub struct RotatingBuffer<T: Default + Copy, const S: usize> {
    pub inner: [T; S],
    /* private fields */
}

Fields

inner: [T; S]

Implementations

impl<T: Default + Copy, const S: usize> RotatingBuffer<T, S>

pub fn new() -> RotatingBuffer<T, S>

Examples found in repository

examples/read_to_eof.rs (line 10)

fn main() -> std::io::Result<()> {
    // Unusually small, but we're just proving a point here. Let's just assume we have incredibly
    // limited bandwidth and flexible value lengths, separated by a comma
    let mut buf = RotatingBuffer::<u8, 5>::new();

    let mut stream = TcpStream::connect("127.0.0.1:34254")?;

    loop {
        let read_size = stream.read(buf.get_append_only())?;
        if read_size != 0 {
            // read_size and _buf_size may diverge because add_len extends data that was
            // right-rotated previously
            let _buf_size = buf.add_len(read_size);
        }

        // .as_slice() will provide a slice combining previous right-rotated
        // data as well as newly written data
        let incoming = str::from_utf8(buf.as_slice()).unwrap();

        // Print every comma separated value on a separate line, even if the buffer is too small to
        // hold the entire value, except if it's "EOF\n"
        if !incoming.ends_with("EOF\n") && read_size != 0 || incoming.len() > 4 {
            if let Some(index) = incoming.rfind(',') {
                for value in incoming[..index].split(',') {
                    println!("{}", value);
                }
                // Do not include the comma when rotating and resizing
                buf.rotate_right_and_resize_at(index + 1);
            } else {
                // Here we could push to a heap-allocated structure if appropriate, but we'd need to
                // adapt the logic above to account for when this value is completed by a comma
                print!("{}", incoming);
                buf.resize(0);
            }
        } else {
            return Ok(());
        }
    }
}

pub fn as_slice(&self) -> &[T]

Extracts slice with the length of the buffer’s internally tracked size

Example

let mut buf = RotatingBuffer::<u128, 20>::new();
assert_eq!(buf.as_slice().len(), 0);

buf.add_len(15);
assert_eq!(buf.as_slice().len(), 15);

Examples found in repository

examples/read_to_eof.rs (line 24)

fn main() -> std::io::Result<()> {
    // Unusually small, but we're just proving a point here. Let's just assume we have incredibly
    // limited bandwidth and flexible value lengths, separated by a comma
    let mut buf = RotatingBuffer::<u8, 5>::new();

    let mut stream = TcpStream::connect("127.0.0.1:34254")?;

    loop {
        let read_size = stream.read(buf.get_append_only())?;
        if read_size != 0 {
            // read_size and _buf_size may diverge because add_len extends data that was
            // right-rotated previously
            let _buf_size = buf.add_len(read_size);
        }

        // .as_slice() will provide a slice combining previous right-rotated
        // data as well as newly written data
        let incoming = str::from_utf8(buf.as_slice()).unwrap();

        // Print every comma separated value on a separate line, even if the buffer is too small to
        // hold the entire value, except if it's "EOF\n"
        if !incoming.ends_with("EOF\n") && read_size != 0 || incoming.len() > 4 {
            if let Some(index) = incoming.rfind(',') {
                for value in incoming[..index].split(',') {
                    println!("{}", value);
                }
                // Do not include the comma when rotating and resizing
                buf.rotate_right_and_resize_at(index + 1);
            } else {
                // Here we could push to a heap-allocated structure if appropriate, but we'd need to
                // adapt the logic above to account for when this value is completed by a comma
                print!("{}", incoming);
                buf.resize(0);
            }
        } else {
            return Ok(());
        }
    }
}

pub fn get_append_only(&mut self) -> &mut [T]

Returns a mutable slice with the length of the currently “unused” allocation of the buffer

Example

let mut buf = RotatingBuffer::<u8, 5>::new();
buf.add_len(3);

assert_eq!(buf.get_append_only().len(), 2);
buf.get_append_only()[0] = 50;
assert_eq!(buf.inner, [0, 0, 0, 50, 0]);

Examples found in repository

examples/read_to_eof.rs (line 15)

fn main() -> std::io::Result<()> {
    // Unusually small, but we're just proving a point here. Let's just assume we have incredibly
    // limited bandwidth and flexible value lengths, separated by a comma
    let mut buf = RotatingBuffer::<u8, 5>::new();

    let mut stream = TcpStream::connect("127.0.0.1:34254")?;

    loop {
        let read_size = stream.read(buf.get_append_only())?;
        if read_size != 0 {
            // read_size and _buf_size may diverge because add_len extends data that was
            // right-rotated previously
            let _buf_size = buf.add_len(read_size);
        }

        // .as_slice() will provide a slice combining previous right-rotated
        // data as well as newly written data
        let incoming = str::from_utf8(buf.as_slice()).unwrap();

        // Print every comma separated value on a separate line, even if the buffer is too small to
        // hold the entire value, except if it's "EOF\n"
        if !incoming.ends_with("EOF\n") && read_size != 0 || incoming.len() > 4 {
            if let Some(index) = incoming.rfind(',') {
                for value in incoming[..index].split(',') {
                    println!("{}", value);
                }
                // Do not include the comma when rotating and resizing
                buf.rotate_right_and_resize_at(index + 1);
            } else {
                // Here we could push to a heap-allocated structure if appropriate, but we'd need to
                // adapt the logic above to account for when this value is completed by a comma
                print!("{}", incoming);
                buf.resize(0);
            }
        } else {
            return Ok(());
        }
    }
}

pub fn is_empty(&self) -> bool

Returns true if the buffer’s internal size is 0

pub fn len(&self) -> usize

Returns internally tracked length

pub fn capacity(&self) -> usize

Returns the capacity of this buffer

pub fn resize(&mut self, new_len: usize)

Manually set the internal size of the buffer

Panics

Panics if the new size is bigger than its capacity

Examples found in repository

examples/read_to_eof.rs (line 39)

fn main() -> std::io::Result<()> {
    // Unusually small, but we're just proving a point here. Let's just assume we have incredibly
    // limited bandwidth and flexible value lengths, separated by a comma
    let mut buf = RotatingBuffer::<u8, 5>::new();

    let mut stream = TcpStream::connect("127.0.0.1:34254")?;

    loop {
        let read_size = stream.read(buf.get_append_only())?;
        if read_size != 0 {
            // read_size and _buf_size may diverge because add_len extends data that was
            // right-rotated previously
            let _buf_size = buf.add_len(read_size);
        }

        // .as_slice() will provide a slice combining previous right-rotated
        // data as well as newly written data
        let incoming = str::from_utf8(buf.as_slice()).unwrap();

        // Print every comma separated value on a separate line, even if the buffer is too small to
        // hold the entire value, except if it's "EOF\n"
        if !incoming.ends_with("EOF\n") && read_size != 0 || incoming.len() > 4 {
            if let Some(index) = incoming.rfind(',') {
                for value in incoming[..index].split(',') {
                    println!("{}", value);
                }
                // Do not include the comma when rotating and resizing
                buf.rotate_right_and_resize_at(index + 1);
            } else {
                // Here we could push to a heap-allocated structure if appropriate, but we'd need to
                // adapt the logic above to account for when this value is completed by a comma
                print!("{}", incoming);
                buf.resize(0);
            }
        } else {
            return Ok(());
        }
    }
}

pub fn add_len(&mut self, new_len: usize) -> usize

Add to the current internal length of the buffer

Example

let mut buf = RotatingBuffer::<u8, 5>::new();
assert_eq!(buf.len(), 0);

buf.add_len(3);
assert_eq!(buf.len(), 3);
buf.add_len(1);
assert_eq!(buf.len(), 4);

Examples found in repository

examples/read_to_eof.rs (line 19)

fn main() -> std::io::Result<()> {
    // Unusually small, but we're just proving a point here. Let's just assume we have incredibly
    // limited bandwidth and flexible value lengths, separated by a comma
    let mut buf = RotatingBuffer::<u8, 5>::new();

    let mut stream = TcpStream::connect("127.0.0.1:34254")?;

    loop {
        let read_size = stream.read(buf.get_append_only())?;
        if read_size != 0 {
            // read_size and _buf_size may diverge because add_len extends data that was
            // right-rotated previously
            let _buf_size = buf.add_len(read_size);
        }

        // .as_slice() will provide a slice combining previous right-rotated
        // data as well as newly written data
        let incoming = str::from_utf8(buf.as_slice()).unwrap();

        // Print every comma separated value on a separate line, even if the buffer is too small to
        // hold the entire value, except if it's "EOF\n"
        if !incoming.ends_with("EOF\n") && read_size != 0 || incoming.len() > 4 {
            if let Some(index) = incoming.rfind(',') {
                for value in incoming[..index].split(',') {
                    println!("{}", value);
                }
                // Do not include the comma when rotating and resizing
                buf.rotate_right_and_resize_at(index + 1);
            } else {
                // Here we could push to a heap-allocated structure if appropriate, but we'd need to
                // adapt the logic above to account for when this value is completed by a comma
                print!("{}", incoming);
                buf.resize(0);
            }
        } else {
            return Ok(());
        }
    }
}

pub fn rotate_right_and_resize(&mut self, k: usize)

Rotates the buffer contents in place (see core::slice::rotate_right) and subsequently changes the buffer’s internal length to however much was rotated

Example

let mut buf = RotatingBuffer::<bool, 5>::new();
buf.get_append_only()[3] = true;
buf.add_len(5);

buf.rotate_right_and_resize(2);
assert_eq!(buf.as_slice()[0], true);
assert_eq!(buf.len(), 2);

pub fn rotate_right_and_resize_at(&mut self, index: usize)

Rotate and resize buffer by supplying an index rather than a length

Example

let mut buf = RotatingBuffer::<bool, 5>::new();
buf.get_append_only()[3] = true;
buf.add_len(5);

buf.rotate_right_and_resize_at(3);
assert_eq!(buf.as_slice()[0], true);
assert_eq!(buf.len(), 2);

Examples found in repository

examples/read_to_eof.rs (line 34)

fn main() -> std::io::Result<()> {
    // Unusually small, but we're just proving a point here. Let's just assume we have incredibly
    // limited bandwidth and flexible value lengths, separated by a comma
    let mut buf = RotatingBuffer::<u8, 5>::new();

    let mut stream = TcpStream::connect("127.0.0.1:34254")?;

    loop {
        let read_size = stream.read(buf.get_append_only())?;
        if read_size != 0 {
            // read_size and _buf_size may diverge because add_len extends data that was
            // right-rotated previously
            let _buf_size = buf.add_len(read_size);
        }

        // .as_slice() will provide a slice combining previous right-rotated
        // data as well as newly written data
        let incoming = str::from_utf8(buf.as_slice()).unwrap();

        // Print every comma separated value on a separate line, even if the buffer is too small to
        // hold the entire value, except if it's "EOF\n"
        if !incoming.ends_with("EOF\n") && read_size != 0 || incoming.len() > 4 {
            if let Some(index) = incoming.rfind(',') {
                for value in incoming[..index].split(',') {
                    println!("{}", value);
                }
                // Do not include the comma when rotating and resizing
                buf.rotate_right_and_resize_at(index + 1);
            } else {
                // Here we could push to a heap-allocated structure if appropriate, but we'd need to
                // adapt the logic above to account for when this value is completed by a comma
                print!("{}", incoming);
                buf.resize(0);
            }
        } else {
            return Ok(());
        }
    }
}

Trait Implementations

impl<T: Clone + Default + Copy, const S: usize> Clone for RotatingBuffer<T, S>

fn clone(&self) -> RotatingBuffer<T, S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Default + Copy, const S: usize> Debug for RotatingBuffer<T, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default + Copy, const S: usize> Default for RotatingBuffer<T, S>

Maybe just to allow RotatingBuffer<RotatingBuffer<T, S>, S> 😄

Example

let mut buf = RotatingBuffer::<RotatingBuffer<u8, 10>, 5>::new();
buf.add_len(2);
let slice = buf.as_slice();
assert_eq!(slice[0].inner, slice[1].inner);

But why!

fn default() -> Self

Returns the “default value” for a type.

impl<T: Copy + Default + Copy, const S: usize> Copy for RotatingBuffer<T, S>