Struct batching_queue::Queue

pub struct Queue<T> where
    T: Groupable,  { /* fields omitted */ }

The Queue

Stores elements in groups as defined by their implementation of Groupable.

#[derive(Debug, PartialEq, Eq)]
enum Group {
    G1,
    G2
}

use Group::{G1, G2};
let mut q = Queue::new();
q.push(G1);
q.push(G2);
q.push(G1);
assert_eq!(q.pop(), Some(G1));
assert_eq!(q.pop(), Some(G1));
assert_eq!(q.pop(), Some(G2));
assert_eq!(q.pop(), None);

Implementations

impl<T: Groupable> Queue<T>

pub fn new() -> Self

Construct an empty queue

#[derive(Debug, PartialEq, Eq)]
enum Group {
    G1,
    G2
}

use Group::{G1, G2};
let q = Queue::<Group>::new();

pub fn is_empty(&self) -> bool

Check if the queue is empty

#[derive(Debug, PartialEq, Eq)]
enum Group {
    G1,
    G2
}

use Group::{G1, G2};
let mut q = Queue::new();
assert!(q.is_empty());
q.push(G1);
assert!(!q.is_empty());

pub fn push(&mut self, val: T)

Push the value into the queue

#[derive(Debug, PartialEq, Eq)]
enum Group {
    G1,
    G2
}

use Group::{G1, G2};
let mut q = Queue::new();
q.push(G1);
q.push(G2);

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

Pop the head from the queue

#[derive(Debug, PartialEq, Eq)]
enum Group {
    G1,
    G2
}

use Group::{G1, G2};
let mut q = Queue::new();
q.push(G1);
assert_eq!(q.pop(), Some(G1));
assert_eq!(q.pop(), None);

pub fn pop_group(&mut self) -> Vec<T>

Pop a whole group from the front of the queue and return a vector of the popped elements

An empty vector is returned if the queue is empty

#[derive(Debug, PartialEq, Eq)]
enum Group {
    G1,
    G2
}

use Group::{G1, G2};
let mut q = Queue::new();
q.push(G1);
q.push(G2);
q.push(G1);
assert_eq!(q.pop_group(), [G1, G1]);

Trait Implementations

impl<T: Debug> Debug for Queue<T> where
    T: Groupable, 

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

Formats the value using the given formatter.

impl<T: Groupable> Drop for Queue<T>

pub fn drop(&mut self)

Executes the destructor for this type.