Struct rudac::queue::Circular

pub struct Circular<T> { /* fields omitted */ }

A circular buffer, circular queue, ring buffer is a data structure that uses a single, fixed-size buffer as if it were connected end-to-end. This structure lends itself easily to buffering data streams.

Examples

let mut circular_buffer: rudac::queue::Circular<usize> = rudac::queue::Circular::new(1);

circular_buffer.enqueue(1);

match circular_buffer.dequeue() {
    Some(data) => assert_eq!(*data, 1),
    None => panic!("Data must not be empty")
}

Implementations

impl<T> Circular<T>

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

Creates a new instance of circular queue

Arguments

• capacity - capacity of the queue. note that the real capacity is equal to capacity determined by the argument + 1

Examples

let mut circular_buffer: rudac::queue::Circular<usize> = rudac::queue::Circular::new(1);

pub fn size(&self) -> usize

Returns number of items in the queue

Examples

let mut circular_buffer: rudac::queue::Circular<usize> = rudac::queue::Circular::new(1);
assert_eq!(circular_buffer.size(), 0);

circular_buffer.enqueue(1);
assert_eq!(circular_buffer.size(), 1);

pub fn empty(&self) -> bool

Returns wether queue is empty or not. this implies wether size is equal to 0 or not. capacity will stay the same.

Examples

let mut circular_buffer: rudac::queue::Circular<usize> = rudac::queue::Circular::new(1);
assert_eq!(circular_buffer.empty(), true);

circular_buffer.enqueue(1);
assert_eq!(circular_buffer.empty(), false);

pub fn full(&self) -> bool

Returns true if there are no more room for inserting new items.

Examples

let mut circular_buffer: rudac::queue::Circular<usize> = rudac::queue::Circular::new(1);
assert_eq!(circular_buffer.full(), false);

circular_buffer.enqueue(1);
assert_eq!(circular_buffer.full(), true);

pub fn enqueue(&mut self, element: T)

If queue is not full it will insert an element at the end of the queue. If queue is full, oldest item will be discarded and new item will be inserted at the end of the queue.

Arguments

• element: item to be inserted in the queue

Examples

let mut circular_buffer: rudac::queue::Circular<usize> = rudac::queue::Circular::new(1);

circular_buffer.enqueue(1);

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

Returns and discards the item at the front of the queue. Returns None if there are no items in the queue.

Examples

let mut circular_buffer: rudac::queue::Circular<usize> = rudac::queue::Circular::new(1);

circular_buffer.enqueue(1);

match circular_buffer.dequeue() {
    Some(data) => assert_eq!(*data, 1),
    None => panic!("Data must not be empty")
}

pub fn map(&mut self, transform: fn(_: &T) -> T)

Transforms each element in the queue using the transform function provided

Arguments

• transform: function that transforms each element of the queue and returns that transformed element

Examples

fn all_caps(text: &String) -> String {
    return text.to_uppercase();
}

let mut circular_buffer: rudac::queue::Circular<String> = rudac::queue::Circular::new(1);

circular_buffer.enqueue(String::from("element"));

circular_buffer.map(all_caps);

match circular_buffer.dequeue() {
    Some(data) => assert_eq!(*data, String::from("ELEMENT")),
    None => panic!("Data must not be None")
}

pub fn map_closure<F>(&mut self, transform: F) where
    F: Fn(&T) -> T, 

Transforms each element in the queue using the transform closure provided

Arguments

• transform: closure that transforms each element of the queue and returns that transformed element

Examples

let mut circular_buffer: rudac::queue::Circular<String> = rudac::queue::Circular::new(1);

circular_buffer.enqueue(String::from("element"));

circular_buffer.map_closure(|text: &String| -> String{text.to_uppercase()});

match circular_buffer.dequeue() {
    Some(data) => assert_eq!(*data, String::from("ELEMENT")),
    None => panic!("Data must not be None")
}

pub fn clear(&mut self)

Clears the queue and resets internal flags

Trait Implementations

impl<T: Debug> Debug for Circular<T>

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

Formats the value using the given formatter.

impl<T> Index<usize> for Circular<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Circular<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a Circular<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = CircularIterator<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.