Trait StQueue 

pub trait StQueue {
    type PushBack<Elem>: StQueue;
    type Front;
    type Back: StQueue;

    const LEN: usize;

    // Required methods
    fn push<Elem>(self, element: Elem) -> Self::PushBack<Elem>;
    fn front(&self) -> &Self::Front;
    fn front_mut(&mut self) -> &mut Self::Front;
    fn into_front(self) -> Self::Front;

    // Provided method
    fn len(&self) -> usize { ... }
}

A strongly typed non-empty queue of heterogeneous elements.

There exist two implementations:

• QueueSingle which includes exactly one element, and
• Queue containing multiple (>=2) elements.

Also see define_queue macro to define a queue of heterogeneous elements all of which exhibit a common behavior, or implement a common set of traits. For more information, please see

• examples 3_composition_idea and 5_solution_with_macros; and
• the article zero cost composition.

Required Associated Constants

const LEN: usize

Number of elements in the queue.

Required Associated Types

type PushBack<Elem>: StQueue

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

type Front

Type of the element at the front of the queue.

type Back: StQueue

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

Required Methods

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

Pushes the element and returns the resulting queue.

Type of the resulting queue is known by the generic associated type Self::PushBack<Elem>.

Examples

use orx_meta::queue::*;

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

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

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

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

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

Examples

use orx_meta::queue::*;

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

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

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

let (flag, queue) = queue.pop();
assert_eq!(flag, true);
assert_eq!(queue.front(), &'x');

let (c, queue) = queue.pop();
assert_eq!(c, 'x');
assert_eq!(queue.front(), &"foo");

let s = queue.pop();
assert_eq!(s, "foo");

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

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

Examples

use orx_meta::queue::*;

let mut queue = Queue::new(42).push(true).push('x');

*queue.front_mut() *= 2;
*queue.back_mut().front_mut() = false;
*queue.back_mut().back_mut().front_mut() = 'y';

assert_eq!(queue.as_tuple(), (&84, &false, &'y'));

fn into_front(self) -> Self::Front

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

Examples

use orx_meta::queue::*;

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

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

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

assert_eq!(queue.into_front(), 'x');

Provided Methods

fn len(&self) -> usize

Pushes the element and returns the resulting queue.

This method is provided for convention. Length of the queue is actually known by the constant Self::LEN.

Examples

use orx_meta::queue::*;

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

let queue = Queue::new(42).push(true).push('x');
assert_eq!(queue.len(), 3);

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

let queue = queue.push(true);
assert_eq!(queue.len(), 3);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<F> StQueue for QueueSingle<F>

const LEN: usize = 1usize

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

type Front = F

type Back = QueueSingle<F>

impl<F, B> StQueue for Queue<F, B>

where B: StQueue,

const LEN: usize

type PushBack<Elem> = Queue<F, <B as StQueue>::PushBack<Elem>>

type Front = F

type Back = B