Struct Lobby

Source

pub struct Lobby<T, const N: usize> { /* private fields */ }

Expand description

A const-size queue-like data structure.

Implementations§

Source §

impl<T, const N: usize> Lobby<T, N>

Source

pub const fn new(arr: [Option<T>; N]) -> Self

Create a new Lobby. The caller must pass in an array of all None.

§Limitation

Until some workaround/fix for #44796 becomes available, an initial array must be passed in.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None, None]);
lobby.push(0);

Source

pub const fn first(&self) -> Option<&T>

Get the head item.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);
assert_eq!(None, lobby.first());

lobby.push(0);
assert_eq!(Some(&0), lobby.first());

lobby.push(1);
assert_eq!(Some(&0), lobby.first());

Source

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

Get a mutable reference to the head item. See Self::first.

Source

pub const fn last(&self) -> Option<&T>

Get the tail item.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);
assert_eq!(None, lobby.last());

lobby.push(0);
assert_eq!(Some(&0), lobby.last());

lobby.push(1);
assert_eq!(Some(&1), lobby.last());

Source

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

Get a mutable reference to the head item. See Self::last.

Source

pub const fn nth(&self, n: usize) -> Option<&T>

Get the nth item.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);
assert_eq!(None, lobby.nth(1));

lobby.push(0);
assert_eq!(None, lobby.nth(1));

lobby.push(1);
assert_eq!(Some(&1), lobby.nth(1));

§Panics

Panics if n is greater than or equal to N.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);
lobby.push(0);

let _ = lobby.nth(3);

Source

pub fn nth_mut(&mut self, n: usize) -> Option<&mut T>

Get a mutable reference to the nth item. See Self::nth.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);

lobby.push(0);
lobby.push(1);

let v1 = lobby.nth_mut(1).unwrap();
*v1 = 3;

assert_eq!(Some(&3), lobby.nth(1));

§Panics

Panics under the same conditions as Self::nth.

Source

pub fn push(&mut self, v: T) -> Option<T>

Push a new item to the lobby, returning the head if the lobby is currently full.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);

lobby.push(0);
assert_eq!(Some(&0), lobby.first());

lobby.push(1);
assert_eq!(Some(&0), lobby.first());

lobby.push(2);
assert_eq!(Some(&0), lobby.first());

lobby.push(3);
assert_eq!(Some(&1), lobby.first());

Source

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

Shift out the head item from the lobby.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);
lobby.push(0);
lobby.push(1);
lobby.push(2);

assert_eq!(Some(0), lobby.shift());
assert_eq!(Some(1), lobby.shift());
assert_eq!(Some(2), lobby.shift());
assert_eq!(None, lobby.shift());

Source

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

Pop off the tail item from the lobby.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);
lobby.push(0);
lobby.push(1);
lobby.push(2);

assert_eq!(Some(2), lobby.pop());
assert_eq!(Some(1), lobby.pop());
assert_eq!(Some(0), lobby.pop());
assert_eq!(None, lobby.pop());

Source

pub const fn is_empty(&self) -> bool

Returns true if the Lobby is empty, false if it is not.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);
assert!(lobby.is_empty());

lobby.push(0);
assert!(!lobby.is_empty());

lobby.shift();
assert!(lobby.is_empty());

Source

pub const fn is_full(&self) -> bool

Returns true if the Lobby is full, false if it is not.

use lobby_queue::Lobby;

let mut lobby = Lobby::new([None, None, None]);
assert!(!lobby.is_full());

lobby.push(0);
assert!(!lobby.is_full());

lobby.push(1);
assert!(!lobby.is_full());

lobby.push(2);
assert!(lobby.is_full());