Struct QueueSingle 

pub struct QueueSingle<Front> { /* private fields */ }

A statically-typed queue containing exactly one element of type Front.

See also the other StQueue implementation Queue which can be created by pushing a second element to this queue.

Implementations

impl<X1> QueueSingle<X1>

pub fn into_tuple(self) -> X1

Converts the queue into its flat tuple representation.

Examples

use orx_meta::queue::*;

let queue = Queue::new(42);
assert_eq!(queue.into_tuple(), 42);

let queue = Queue::new(42).push(true);
assert_eq!(queue.into_tuple(), (42, true));

let queue = Queue::new(42).push(true).push('x').push("foo");
assert_eq!(queue.into_tuple(), (42, true, 'x', "foo"));

pub fn as_tuple(&self) -> &X1

Returns a flat tuple representation of references to elements in the queue.

Examples

use orx_meta::queue::*;

let queue = Queue::new(42);
assert_eq!(queue.as_tuple(), &42);

let queue = Queue::new(42).push(true);
assert_eq!(queue.as_tuple(), (&42, &true));

let queue = Queue::new(42).push(true).push('x').push("foo");
assert_eq!(queue.as_tuple(), (&42, &true, &'x', &"foo"));

pub fn as_tuple_mut(&mut self) -> &mut X1

Returns a flat tuple representation of mutable references to elements in the queue.

Examples

use orx_meta::queue::*;

let mut queue = Queue::new(42);
let a = queue.as_tuple_mut();
*a *= 2;
assert_eq!(queue.as_tuple(), &84);

let mut queue = Queue::new(42).push(true);
let (a, b) = queue.as_tuple_mut();
*a *= 2;
*b = false;
assert_eq!(queue.as_tuple(), (&84, &false));

let mut queue = Queue::new(42).push(true).push('x').push("foo");
let (a, b, c, d) = queue.as_tuple_mut();
*a *= 2;
*b = false;
*c = 'y';
*d = "bar";
assert_eq!(queue.as_tuple(), (&84, &false, &'y', &"bar"));

impl<F> QueueSingle<F>

pub fn new(element: F) -> Self

Creates a new statically-typed queue StQueue containing exactly one element.

Alternatively, we can use multiple element queue’s new. This is for convenience to allows to work with a single queue type while coding.

Examples

use orx_meta::queue::*;

let queue: QueueSingle<u32> = QueueSingle::new(42);
assert_eq!(queue.len(), 1);
assert_eq!(queue.front(), &42);

// alternatively, we can use `Queue::new`:
let queue: QueueSingle<u32> = Queue::new(42);
assert_eq!(queue.len(), 1);
assert_eq!(queue.front(), &42);

pub fn pop(self) -> F

Pops and returns the element in the front of this queue.

Since this element contains only one element, there is no remaining queue once the front is popped. Therefore, the return type is only the element rather than a tuple.

Examples

use orx_meta::queue::*;

let queue: QueueSingle<u32> = QueueSingle::new(42);

let num = queue.pop();
assert_eq!(num, 42);

Trait Implementations

impl<Front: Clone> Clone for QueueSingle<Front>

fn clone(&self) -> QueueSingle<Front>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Front: Debug> Debug for QueueSingle<Front>

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

Formats the value using the given formatter.

impl<Front: PartialEq> PartialEq for QueueSingle<Front>

fn eq(&self, other: &QueueSingle<Front>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F> StQueue for QueueSingle<F>

const LEN: usize = 1usize

Number of elements in the queue.

type PushBack<Elem> = Queue<F, QueueSingle<Elem>>

Type of the queue obtained by adding an element of type Elem to this queue.

type Front = F

Type of the element at the front of the queue.

type Back = QueueSingle<F>

Type of the queue that would be obtained by popping the Front element of the queue.

fn push<Elem>(self, element: Elem) -> Self::PushBack<Elem>

Pushes the element and returns the resulting queue.

fn front(&self) -> &Self::Front

Returns a reference to the element in the front of the queue.

fn front_mut(&mut self) -> &mut Self::Front

Returns a mutable reference to the element in the front of the queue.

fn into_front(self) -> Self::Front

Consumes the queue and returns the element in the front of the queue.

fn len(&self) -> usize

Pushes the element and returns the resulting queue.

impl<Front: Copy> Copy for QueueSingle<Front>

impl<Front: Eq> Eq for QueueSingle<Front>

impl<Front> StructuralPartialEq for QueueSingle<Front>