Struct Buffer

pub struct Buffer<T: Clone> { /* private fields */ }

A FIFO buffer with a growable size and a capacity limit

Type parameters

• T: Any type that implements the Clone trait.

Examples

let mut buf = Buffer::new(3);

// Add some elements
assert_eq!(buf.add(6), Ok(None));
assert_eq!(buf.add(7), Ok(None));

// Remove an element
assert_eq!(buf.remove(), Ok(6));

// Peek at the next element scheduled for removal
assert_eq!(buf.peek(), Ok(7));

// Check the queue size
assert_eq!(buf.size(), 1);

Implementations

impl<T: Clone> Buffer<T>

pub fn new(capacity: usize) -> Buffer<T>

Create a new buffer

Returns

A new, empty Buffer<T>

Examples

let buf: Buffer<isize> = Buffer::new(3);
assert_eq!(buf.size(), 0);

Examples found in repository

examples/buf.rs (line 11)

fn main() {
    println!("\nBuffer - typical usage");
    println!("--");

    println!("\nCreate a new empty buffer:");
    println!("let mut buf: Buffer<isize> = Buffer::new(3);");
    let mut buf: Buffer<isize> = Buffer::new(3);

    println!("\nAdd elements to it:");
    println!("buf.add(1);");
    println!("> {:?}", buf.add(1));
    println!("buf.add(-2);");
    println!("> {:?}", buf.add(-2));
    println!("buf.add(3);");
    println!("> {:?}", buf.add(3));

    println!("\nAttempt to add elements when full:");
    println!("buf.add(-4);  // Should raise an error");
    println!("> {:?}", buf.add(-4));

    println!("\nCheck the buffer's size:");
    println!("buf.size();  // Should be 3");
    println!("> {}", buf.size());

    println!("\nRemove elements from it:");
    println!("buf.remove();  // Should be Ok(1)");
    println!("> {:?}", buf.remove());

    println!("\nCheck the buffer's size:");
    println!("buf.size();  // Should be 2");
    println!("> {}", buf.size());

    println!("\nPeek at the next element to be removed:");
    println!("buf.peek();  // Should be Ok(-2)");
    println!("> {:?}", buf.peek());

    println!("\nCheck the queue's size:");
    println!("buf.size();  // Should be 2");
    println!("> {}", buf.size());

    println!("\nRemove more elements from it:");
    println!("buf.remove();  // Should be Ok(-2)");
    println!("> {:?}", buf.remove());
    println!("buf.remove();  // Should be Ok(3)");
    println!("> {:?}", buf.remove());

    println!("\nPeek at the next element to be removed:");
    println!("buf.peek();  // Should raise an error");
    println!("> {:?}", buf.peek());

    println!("\nAttempt to remove elements from it:");
    println!("buf.remove();  // Should raise an error");
    println!("> {:?}", buf.remove());

    println!("\n--\n")
}

pub fn capacity(&self) -> usize

Gets the capacity of the buffer

Returns

The number of allowed elements in the buffer

Examples

let mut buf: Buffer<isize> = Buffer::new(5);
assert_eq!(buf.capacity(), 5);

Trait Implementations

impl<T: Debug + Clone> Debug for Buffer<T>

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

Formats the value using the given formatter.

impl<T: Clone> IsQueue<T> for Buffer<T>

fn add(&mut self, val: T) -> Result<Option<T>, &str>

Adds an element to a buffer

Parameters

• val: Value to add to the buffer

Returns

• Ok(None): Element addition was successful
• Error

Errors

Returns an error if an attempt is made to add an element to a full buffer

Examples

use queues::*;

let mut buf: Buffer<isize> = Buffer::new(3);
assert_eq!(buf.add(42), Ok(None));

fn remove(&mut self) -> Result<T, &str>

Removes an element from the buffer and returns it.

Returns

• Ok(T): The oldest element in the buffer
• Error

Errors

Returns an error if an attempt is made to remove an element from an empty buffer

Examples

let mut buf: Buffer<isize> = Buffer::new(3);
buf.add(42);
assert_eq!(buf.remove(), Ok(42));
assert_eq!(buf.size(), 0);

fn peek(&self) -> Result<T, &str>

Peek at the head of the buffer

Returns

• Ok(T): The next element scheduled for removal from the buffer
• Error

Errors

Returns an error if an attempt is made to peek into an empty buffer

Examples

let mut buf: Buffer<isize> = Buffer::new(3);
buf.add(42);
assert_eq!(buf.peek(), Ok(42));

fn size(&self) -> usize

Gets the size of the buffer

Returns

The number of elements in the buffer.

Examples

let mut buf: Buffer<isize> = Buffer::new(3);
assert_eq!(buf.size(), 0);
buf.add(42);
assert_eq!(buf.size(), 1);