Struct Destaque 

pub struct Destaque<T, const CAP: usize, IDX, S: Storage = Bare> { /* private fields */ }

Available on _destaque·· only.

🗃️ A static double-ended queue and stack backed by an Array.

---

^{📍 data/layout/queue}

---

It is generic in respect to its elements (T), capacity (CAP), index size (IDX) and storage (S).

The index size will upper-bound the capacity to the maximum for that type, e.g. u8::MAX for DestaqueU8.

The index size determines the maximum possible number of elements in the destaque, thereby upper-bounding the capacity to the maximum value representable by the index type. For example, u8::MAX for DestaqueU8.

The total size in bytes of the stack may be influenced by the chosen index size, depending on the size and alignment of the elements. This difference could only be significant for small capacities, as only one index is stored.

See also the related aliases that specify IDX: DestaqueU8, [DestaqueU16], [DestaqueU32], [DestaqueUsize], and the related traits: DataQueue, DataDeque, DataStack, DataDesta.

Methods

It implements methods that operate from both the front and the back. Rememeber that a single-ended stack operates only from the back, while a single-ended queue pushes to the back and pops from the front.

• General methods:

  • new, len, is_empty, is_full, clear, contains, capacity, remaining_capacity.
  • iter, extend_back, extend_front, from_array(copy), to_array, to_vec.

• Queue and stack methods:

  • push: push_back(uc) = enqueue, push_front(uc).
  • pop: pop_front = dequeue, pop_back.
  • peek: peek_back(mut) peek_nth_back(mut), peek_front(mut), peek_nth_front(mut).
  • drop: drop_back, drop_front, drop_n_back, drop_n_front.
  • swap: swap_back(uc), swap_front(uc), swap2_back(uc), swap2_front(uc), swap_ends, swap2_ends.
  • rot: rot_right, rot_right_n, rot_left, rot_left_n.
  • dup: dup_back, dup_front, dup2_back, dup2_front.
  • over: over_back, over_front, over2_back, over2_front.
  • tuck: tuck_back, tuck_front, tuck2_back, tuck2_front.

Implementations

impl<T: Clone, const CAP: usize> Destaque<T, CAP, u8, Bare>

This impl block contains no public items.

Methods for DestaqueU8

---

---

impl<T: Clone, const CAP: usize> Destaque<T, CAP, u8, Bare>

pub fn new(element: T) -> Result<Self, MismatchedCapacity>

Returns an empty destaque, allocated in the stack, cloning element to fill the remaining free data.

Errors

Returns MismatchedCapacity if CAP > u8::MAX or if CAP > isize::MAX / size_of::<T>().

Examples

let q = DestaqueU8::<_, 16>::new(0).unwrap();

impl<T: Copy, const CAP: usize> Destaque<T, CAP, u8, Bare>

pub const fn new_copied(element: T) -> Result<Self, MismatchedCapacity>

Returns an empty destaque, allocated in the stack, copying element to fill the remaining free data, in compile-time.

Errors

Returns MismatchedCapacity if CAP > u8::MAX or if CAP > isize::MAX / size_of::<T>().

Examples

const S: DestaqueU8<i32, 16> = unwrap![ok DestaqueU8::new_copied(0)];

impl<T: Clone, const CAP: usize> Destaque<T, CAP, u8, Boxed>

pub fn new(element: T) -> Self

Available on crate feature alloc only.

Returns an empty destaque, allocated in the heap, cloning element to fill the remaining free data.

Examples

let q = DestaqueU8::<_, 3, Boxed>::new(0);

impl<T, const CAP: usize> Destaque<T, CAP, u8, Bare>

pub const fn from_array_copy(arr: [T; CAP]) -> Destaque<T, CAP, u8, Bare>

Converts an array into a full destaque.

Examples

let q = DestaqueU8::<_, 3>::from_array([1, 2, 3]);

impl<T, const CAP: usize, S: Storage> Destaque<T, CAP, u8, S>

pub fn from_array(arr: [T; CAP]) -> Destaque<T, CAP, u8, S>

Converts an array into a full destaque.

Examples

let q = DestaqueU8::<_, 3>::from_array([1, 2, 3]);

pub const fn len(&self) -> u8

Returns the number of destaqued elements.

pub const fn is_empty(&self) -> bool

Returns true if the destaque is empty.

Examples

let q = DestaqueU8::<i32, 8>::default();
assert![q.is_empty()];

pub const fn is_full(&self) -> bool

Returns true if the destaque is full.

Examples

let q = DestaqueU8::<_, 3>::from([1, 2, 3]);
assert![q.is_full()];

pub const fn capacity(&self) -> u8

Returns the destaque’s total capacity.

Examples

let q = DestaqueU8::<i32, 3>::default();
assert_eq![3, q.capacity()];

pub const fn remaining_capacity(&self) -> u8

Returns the destaque’s remaining capacity.

Examples

let mut q = DestaqueU8::<i32, 3>::default();
assert_eq![3, q.remaining_capacity()];
q.push_back(1)?;
assert_eq![2, q.remaining_capacity()];

pub fn as_slices(&self) -> (&[T], &[T])

Returns the destaque as pair of shared slices, which contain, in order, the contents of the destaque.

Examples

let q = DestaqueU8::<_, 3>::from([1, 2, 3]);
assert_eq![q.as_slices(), (&[1, 2, 3][..], &[][..])];

pub const fn is_contiguous(&self) -> bool

Returns true if the destaque is contiguous.

Examples

let mut q = DestaqueU8::<_, 3>::from([1, 2, 3]);
assert_eq![q.as_slices(), (&[1, 2, 3][..], &[][..])];
assert![q.is_contiguous()];
q.pop_back()?;
q.push_front(4)?;
assert![!q.is_contiguous()];
assert_eq![q.as_slices(), (&[4][..], &[1, 2][..])];

pub fn push_front(&mut self, element: T) -> Result<(), NotEnoughSpace>

Pushes a new element to the front of the destaque.

( 1 2 -- 3 1 2 )

Errors

Returns NotEnoughSpace if the destaque is full.

Examples

let mut q = DestaqueU8::<u8, 3>::default();
q.push_front(1)?;
q.push_front(2)?;
q.push_front(3)?;
assert_eq![q.to_array(), Some([3, 2, 1])];

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

Unchecked version of push_front.

Panics

Panics if the destaque is full.

pub fn push_front_override(&mut self, element: T) -> bool

Pushes a new element to the front of the destaque, overriding an element from the back if the destaque is full.

Returns true if an element was overridden, and false otherwise.

Examples

let mut q = DestaqueU8::<_, 3>::from([1, 2]);
assert_eq!(q.push_front_override(3), false);
assert_eq![q.to_array(), Some([3, 1, 2])];
assert_eq!(q.push_front_override(4), true);
assert_eq![q.to_array(), Some([4, 3, 1])];

pub fn push_back(&mut self, element: T) -> Result<(), NotEnoughSpace>

Pushes a new element to the back of the destaque.

This is the habitual enqueue operation for a single-ended queue.

( 1 2 -- 1 2 3 )

Errors

Returns NotEnoughSpace if the destaque is full.

Examples

let mut q = DestaqueU8::<u8, 3>::default();
q.push_back(1)?;
q.push_back(2)?;
q.push_back(3)?;
assert_eq![q.to_array(), Some([1, 2, 3])];

pub fn enqueue(&mut self, element: T) -> Result<(), NotEnoughSpace>

Alias of push_back.

This is the habitual enqueue operation for a single-ended queue.

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

Unchecked version of push_back.

Panics

Panics if the destaque is full.

pub fn push_back_override(&mut self, element: T) -> bool

Pushes a new element to the back of the destaque, overriding the first element if the destaque is full.

Returns true if an element was overridden, and false otherwise.

Examples

let mut q = DestaqueU8::<_, 3>::from([1, 2]);
assert_eq!(q.push_back_override(3), false);
assert_eq![q.to_array(), Some([1, 2, 3])];
assert_eq!(q.push_back_override(4), true);
assert_eq![q.to_array(), Some([2, 3, 4])];

pub fn pop_front(&mut self) -> Result<T, NotEnoughElements>

Available on crate feature unsafe_ptr only.

Pops the front element.

This is the habitual dequeue operation for a signle-ended queue.

( 1 2 -- 2 )

Errors

Returns NotEnoughElements if the queue is empty.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2, 3]);
assert_eq![1, q.pop_front()?];
assert_eq![2, q.pop_front()?];
assert_eq![3, q.pop_front()?];
assert![q.is_empty()];

Features

It’s depends on T: Clone, unless the unsafe_ptr feature is enabled.

pub fn dequeue(&mut self) -> Result<T, NotEnoughElements>

Available on crate feature unsafe_ptr only.

Alias of pop_front.

This is the habitual dequeue operation for a single-ended queue.

pub fn pop_back(&mut self) -> Result<T, NotEnoughElements>

Available on crate feature unsafe_ptr only.

Pops the back element.

( 1 2-- 1 )

Errors

Returns NotEnoughElements if the destaque is empty.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2, 3]);
assert_eq![3, q.pop_back()?];
assert_eq![2, q.pop_back()?];
assert_eq![1, q.pop_back()?];
assert![q.is_empty()];

Features

It’s depends on T: Clone, unless the unsafe_ptr feature is enabled.

pub fn peek_back(&self) -> Result<&T, NotEnoughElements>

Returns a shared reference to the back element.

Errors

Returns NotEnoughElements if the destaque is empty.

Examples

let q = DestaqueU8::<_, 8>::from([1, 2, 3]);
assert_eq![&3, q.peek_back()?];

pub fn peek_back_mut(&mut self) -> Result<&mut T, NotEnoughElements>

Returns an exclusive reference to the back element.

Errors

Returns NotEnoughElements if the destaque is empty.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2, 3]);
assert_eq![&mut 3, q.peek_back_mut()?];

pub fn peek_nth_back(&self, nth: u8) -> Result<&T, NotEnoughElements>

Returns a shared reference to the nth back element.

Errors

Returns NotEnoughElements if the destaque doesn’t have at least nth elements.

Examples

let q = DestaqueU8::<_, 8>::from([1, 2, 3]);
assert_eq![&1, q.peek_nth_back(2)?];

pub fn peek_nth_back_mut( &mut self, nth: u8, ) -> Result<&mut T, NotEnoughElements>

Returns an exclusive reference to the nth back element.

Errors

Returns NotEnoughElements if the destaque doesn’t have at least nth elements.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2, 3]);
assert_eq![&mut 1, q.peek_nth_back_mut(2)?];

pub fn peek_front(&self) -> Result<&T, NotEnoughElements>

Returns a shared reference to the front element.

Errors

Returns NotEnoughElements if the destaque is empty.

Examples

let q = DestaqueU8::<_, 8>::from([1, 2, 3]);
assert_eq![&1, q.peek_front()?];

pub fn peek_front_mut(&mut self) -> Result<&mut T, NotEnoughElements>

Returns an exclusive reference to the front element.

Errors

Returns NotEnoughElements if the destaque is empty.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2, 3]);
assert_eq![&mut 1, q.peek_front_mut()?];

pub fn peek_nth_front(&self, nth: u8) -> Result<&T, NotEnoughElements>

Returns a shared reference to the nth front element.

Errors

Returns NotEnoughElements if the destaque doesn’t have at least nth elements.

Examples

let q = DestaqueU8::<_, 8>::from([1, 2, 3, 4]);
assert_eq![&3, q.peek_nth_front(2)?];

pub fn peek_nth_front_mut( &mut self, nth: u8, ) -> Result<&mut T, NotEnoughElements>

Returns an exclusive reference to the nth front element.

Errors

Returns NotEnoughElements if the destaque doesn’t have at least nth elements.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2, 3, 4]);
assert_eq![&mut 3, q.peek_nth_front_mut(2)?];

pub const fn clear(&mut self)

Clears the destaque.

( 1 2 -- )

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2, 3, 4]);
q.clear();
assert![q.is_empty()];

pub fn drop_back(&mut self) -> Result<(), NotEnoughElements>

Drops the back element.

( 1 2 -- 1 )

Errors

Returns NotEnoughElements if the destaque is empty.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2]);
q.drop_back()?;
assert_eq![q.to_array(), Some([1])];

pub fn drop_front(&mut self) -> Result<(), NotEnoughElements>

Drops the front element.

( 1 2 -- 2 )

Errors

Returns NotEnoughElements if the destaque is empty.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2]);
q.drop_front()?;
assert_eq![q.to_array(), Some([2])];

pub fn drop_n_back(&mut self, nth: u8) -> Result<(), NotEnoughElements>

Drops n elements from the back.

( 1 2 3 4 -- 1 ) for n = 3

Errors

Returns NotEnoughElements if the destaque doesn’t contain at least nth elements.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2, 3, 4]);
q.drop_n_back(3)?;
assert_eq![q.to_array(), Some([1])];

pub fn drop_n_front(&mut self, nth: u8) -> Result<(), NotEnoughElements>

Drops n elements from the front.

( 1 2 3 4 -- 4 ) for n = 3

Errors

Returns NotEnoughElements if the destaque doesn’t contain at least nth elements.

Examples

let mut q = DestaqueU8::<_, 8>::from([1, 2, 3, 4]);
q.drop_n_front(3)?;
assert_eq![q.to_array(), Some([4])];

pub fn swap_back(&mut self) -> Result<(), NotEnoughElements>

Swaps the last two elements at the back of the destaque.

( 1 2 3 4 -- 1 2 4 3 )

Errors

Returns NotEnoughElements if the destaque doesn’t contain at least 2 elements.

Examples

let mut q = DestaqueU8::<_, 4>::from([1, 2, 3, 4]);
q.swap_back();
assert_eq![q.to_array(), Some([1, 2, 4, 3])];

pub fn swap_back_unchecked(&mut self)

Unchecked version of swap_back.

Panics

Panics if the destaque doesn’t contain at least 2 elements.

pub fn swap_front(&mut self) -> Result<(), NotEnoughElements>

Swaps the first two elements at the front of the destaque.

( 1 2 3 4 -- 2 1 3 4 )

Errors

Returns NotEnoughElements if the destaque doesn’t contain at least 2 elements.

Examples

let mut q = DestaqueU8::<_, 4>::from([1, 2, 3, 4]);
q.swap_front();
assert_eq![q.to_array(), Some([2, 1, 3, 4])];

pub fn swap_front_unchecked(&mut self)

Unchecked version of swap_front.

Panics

Panics if the destaque doesn’t contain at least 2 elements.

pub fn swap2_back(&mut self) -> Result<(), NotEnoughElements>

Swaps the last two pairs of elements at the back of the destaque.

( 1 2 3 4 5 6 7 8 -- 1 2 3 4 7 8 5 6 )

Errors

Returns NotEnoughElements if the destaque doesn’t contain at least 2 elements.

Examples

let mut q = DestaqueU8::<_, 16>::from([1, 2, 3, 4, 5, 6, 7, 8]);
q.swap2_back();
assert_eq![q.to_array(), Some([1, 2, 3, 4, 7, 8, 5, 6])];

pub fn swap2_back_unchecked(&mut self)

Unchecked version of swap2_back.

Panics

Panics if the destaque doesn’t contain at least 2 elements.

pub fn swap2_front(&mut self) -> Result<(), NotEnoughElements>

Swaps the first two pairs of elements at the front of the destaque. ( 1 2 3 4 5 6 7 8 -- 3 4 1 2 5 6 7 8 )

Errors

Returns NotEnoughElements if the destaque doesn’t contain at least 4 elements.

Examples

let mut q = DestaqueU8::<_, 16>::from([1, 2, 3, 4, 5, 6, 7, 8]);
q.swap2_front();
assert_eq![q.to_array(), Some([3, 4, 1, 2, 5, 6, 7, 8])];

pub fn swap2_front_unchecked(&mut self)

Unchecked version of swap2_back.

Panics

Panics if the destaque doesn’t contain at least 2 elements.

pub fn swap_ends(&mut self) -> Result<(), NotEnoughElements>

Swaps the front and back elements.

( 1 2 3 4 -- 4 2 3 1 )

Errors

Returns NotEnoughElements if the destaque doesn’t contain at least 2 elements.

Examples

let mut q = DestaqueU8::<_, 6>::from([1, 2, 3, 4, 5]);
q.swap_ends();
assert_eq![q.to_array(), Some([5, 2, 3, 4, 1])];

pub fn swap2_ends(&mut self) -> Result<(), NotEnoughElements>

Swaps the front and back pairs of elements.

( 1 2 3 4 5 6 7 8 -- 7 8 3 4 5 6 1 2 )

Errors

Returns NotEnoughElements if the destaque doesn’t contain at least 4 elements.

Examples

let mut q = DestaqueU8::<_, 16>::from([1, 2, 3, 4, 5, 6, 7, 8]);
q.swap2_ends();
assert_eq![q.to_array(), Some([7, 8, 3, 4, 5, 6, 1, 2])];

pub fn rot_right(&mut self)

Rotates all the destaqued elements one place to the right.

( 1 2 3 4 -- 4 1 2 3 )

Examples

let mut q = DestaqueU8::<i32, 8>::from([2, 3]);
q.push_front(1)?;
q.push_back(4)?;
assert_eq![q.to_array(), Some([1, 2, 3, 4])];
q.rot_right();
assert_eq![q.to_array(), Some([4, 1, 2, 3])];

pub fn rot_right_n(&mut self, nth: u8)

Rotates all the destaqued elements n places to the right.

( 1 2 3 4 -- 2 3 4 1 ) for n = 3

Examples

let mut q = DestaqueU8::<i32, 8>::from([2, 3]);
q.push_front(1)?;
q.push_back(4)?;
assert_eq![q.to_array(), Some([1, 2, 3, 4])];
q.rot_right_n(3);
assert_eq![q.to_array(), Some([2, 3, 4, 1])];

pub fn rot_left(&mut self)

Rotates all the destaqued elements one place to the left.

( 1 2 3 4 -- 2 3 4 1 )

Examples

let mut q = DestaqueU8::<i32, 8>::from([2, 3]);
q.push_front(1)?;
q.push_back(4)?;
assert_eq![q.to_array(), Some([1, 2, 3, 4])];
q.rot_left();
assert_eq![q.to_array(), Some([2, 3, 4, 1])];

pub fn rot_left_n(&mut self, nth: u8)

Rotates all the destaqued elements n places to the left.

( 1 2 3 4 -- 4 1 2 3 ) for nth = 3

Examples

let mut q = DestaqueU8::<i32, 8>::from([2, 3]);
q.push_front(1)?;
q.push_back(4)?;
assert_eq![q.to_array(), Some([1, 2, 3, 4])];
q.rot_left_n(3);
assert_eq![q.to_array(), Some([4, 1, 2, 3])];

impl<T: Clone, const CAP: usize, S: Storage> Destaque<T, CAP, u8, S>

pub fn make_contiguous(&mut self, element: T) -> &mut [T]

Makes the elements of the destaque contiguous, rearranging the elements so that they are in a single, continuous block starting from the front.

This operation might rearrange the internal representation of the elements to ensure they are contiguous. It clones the default element provided during the destaque’s construction to fill any gaps if necessary.

Returns a mutable slice to the now contiguous elements.

Examples

let mut q = DestaqueU8::<_, 5>::new(0).unwrap();
q.push_back(1);
q.push_back(2);
q.push_front(5);
assert_eq!(q.as_slices(), (&[5][..], &[1, 2][..]));

assert_eq!(q.make_contiguous(0), &[5, 1, 2]);
assert_eq!(q.as_slices(), (&[5, 1, 2][..], &[][..]));

pub fn to_vec(&self) -> Vec<T>

Available on crate feature alloc only.

Returns the destaqued elements as a vector.

Examples

let mut q = DestaqueU8::<_, 5>::from([3, 4]);
q.push_front(2)?;
q.push_back(5)?;
q.push_front(1)?;
assert_eq![q.to_vec(), vec![1, 2, 3, 4, 5]];

pub fn to_array<const LEN: usize>(&self) -> Option<[T; LEN]>

Returns some LEN destaqued elements as an array, or None if the destaque is empty, or there are not at least LEN elements.

This is a non alloc alternative method to to_vec.

Panics

Panics if the new LEN sized array can’t be allocated.

Examples

let mut q = DestaqueU8::<_, 5>::from([3, 4]);
q.push_front(2)?;
q.push_back(5)?;
q.push_front(1)?;
assert_eq![q.to_array::<5>(), Some([1, 2, 3, 4, 5])];

Features

Makes use of the unsafe_array feature if enabled.

pub fn dup_back(&mut self) -> Result<(), DataNotEnough>

Duplicates the back element at the back

( 1 2 -- 1 2 2 )

Errors

Returns NotEnoughElements if the destaque is empty or NotEnoughSpace if it is full.

Examples

let mut q = DestaqueU8::<u8, 4>::from([1, 2, 3]);
q.dup_back()?;
assert_eq![q.to_array(), Some([1, 2, 3, 3])];

pub fn dup_front(&mut self) -> Result<(), DataNotEnough>

Duplicates the front element at the front.

( 1 2 -- 1 1 2 )

Errors

Returns NotEnoughElements if the destaque is empty or NotEnoughSpace if it is full.

Examples

let mut q = DestaqueU8::<u8, 4>::from([1, 2, 3]);
q.dup_front()?;
assert_eq![q.to_array(), Some([1, 1, 2, 3])];

pub fn dup2_back(&mut self) -> Result<(), DataNotEnough>

Duplicates the back pair of elements, at the back.

( 1 2 3 4 -- 1 2 3 4 3 4)

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 2 elements, or NotEnoughSpace if it doesn’t have space for 2 additional elements.

Examples

let mut q = DestaqueU8::<u8, 6>::from([1, 2, 3, 4]);
q.dup2_back()?;
assert_eq![q.to_array(), Some([1, 2, 3, 4, 3, 4])];

pub fn dup2_front(&mut self) -> Result<(), DataNotEnough>

Duplicates the front pair of elements, at the front.

( 1 2 3 4 -- 1 2 1 2 3 4)

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 2 elements, or NotEnoughSpace if it doesn’t have space for 2 additional elements.

Examples

let mut q = DestaqueU8::<u8, 6>::from([1, 2, 3, 4]);
q.dup2_front()?;
assert_eq![q.to_array(), Some([1, 2, 1, 2, 3, 4])];

pub fn over_back(&mut self) -> Result<(), DataNotEnough>

Duplicates the second back element, at the back.

( 1 2 3 4 -- 1 2 3 4 3 )

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 2 elements, or NotEnoughSpace if it is full.

Examples

let mut q = DestaqueU8::<u8, 7>::from([1, 2, 3, 4]);
q.over_back()?;
assert_eq![q.to_array(), Some([1, 2, 3, 4, 3])];

pub fn over_front(&mut self) -> Result<(), DataNotEnough>

Duplicates the second front element, at the front.

( 1 2 3 4 -- 2 1 2 3 4 )

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 2 elements, or NotEnoughSpace if it is full.

Examples

let mut q = DestaqueU8::<u8, 7>::from([1, 2, 3, 4]);
q.over_front()?;
assert_eq![q.to_array(), Some([2, 1, 2, 3, 4])];

pub fn over2_back(&mut self) -> Result<(), DataNotEnough>

Duplicates the second back pair of elements, at the back.

( 1 2 3 4 5 6 7 8 -- 1 2 3 4 5 6 7 8 5 6 )

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 4 elements, or NotEnoughSpace if it doesn’t have space for 2 additional elements.

Examples

let mut q = DestaqueU8::<u8, 8>::from([1, 2, 3, 4, 5, 6]);
q.over2_back()?;
assert_eq![q.to_array(), Some([1, 2, 3, 4, 5, 6, 3, 4])];

pub fn over2_front(&mut self) -> Result<(), DataNotEnough>

Duplicates the second front pair of elements, at the front.

( 1 2 3 4 5 6 7 8 -- 3 4 1 2 3 4 5 6 7 8 )

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 4 elements, or NotEnoughSpace if it doesn’t have space for 2 additional elements.

Examples

let mut q = DestaqueU8::<u8, 8>::from([1, 2, 3, 4, 5, 6]);
q.over2_front()?;
assert_eq![q.to_array(), Some([3, 4, 1, 2, 3, 4, 5, 6])];

pub fn tuck_back(&mut self) -> Result<(), DataNotEnough>

Duplicates the back element, before the second back element.

( 1 2 3 4 -- 1 2 4 3 4 )

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 2 elements, or NotEnoughSpace if it is full.

Examples

let mut q = DestaqueU8::<u8, 7>::from([1, 2, 3, 4, 5]);
q.tuck_back()?;
assert_eq![q.to_array(), Some([1, 2, 3, 5, 4, 5])];

pub fn tuck_front(&mut self) -> Result<(), DataNotEnough>

Duplicates the front element, after the second front element.

( 1 2 3 4 -- 1 2 1 3 4 )

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 2 elements, or NotEnoughSpace if it is full.

Examples

let mut q = DestaqueU8::<u8, 7>::from([1, 2, 3, 4, 5]);
q.tuck_front()?;
assert_eq![q.to_array(), Some([1, 2, 1, 3, 4, 5])];

pub fn tuck2_back(&mut self) -> Result<(), DataNotEnough>

Duplicates the back pair of elements, before the second back pair of elements.

( 1 2 3 4 5 6 7 8 -- 1 2 3 4 7 8 5 6 7 8 )

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 4 elements, or NotEnoughSpace if it doesn’t have space for 2 additional elements.

Examples

let mut q = DestaqueU8::<u8, 7>::from([1, 2, 3, 4, 5]);
q.tuck2_back()?;
assert_eq![q.to_array(), Some([1, 4, 5, 2, 3, 4, 5])];

pub fn tuck2_front(&mut self) -> Result<(), DataNotEnough>

Duplicates the front pair of elements, after the second front pair of elements.

( 1 2 3 4 5 6 7 8 -- 1 2 3 4 1 2 5 6 7 8 )

Errors

Returns NotEnoughElements if the destaque doesn’t have at least 4 elements, or NotEnoughSpace if it doesn’t have space for 2 additional elements.

Examples

let mut q = DestaqueU8::<u8, 7>::from([1, 2, 3, 4, 5]);
q.tuck2_front()?;
assert_eq![q.to_array(), Some([1, 2, 3, 4, 1, 2, 5])];

impl<T, const CAP: usize, S: Storage> Destaque<T, CAP, u8, S>

pub const fn iter(&self) -> DestaqueIter<'_, T, CAP, u8, S>

Returns an iterator.

pub fn extend_back<I>(&mut self, iterator: I) -> Result<(), NotEnoughSpace>

where I: IntoIterator<Item = T>,

Extends the back of the destaque from an iterator.

( 1 2 -- 1 2 3 4 5 6) for [3 4 5 6]

Errors

Returns NotEnoughSpace if the destaque becomes full before the iterator finishes.

Examples

let mut q = DestaqueU8::<_, 6>::from([1, 2, 3]);
q.extend_back([4, 5, 6, 7, 8]);
assert_eq![q.to_array(), Some([1, 2, 3, 4, 5, 6])];

pub fn extend_back_override<I>(&mut self, iterator: I) -> bool

where I: IntoIterator<Item = T>,

Extends the back of the destaque from an iterator, overriding elements from the front if the destaque is full.

( 1 2 3 -- 3 4 5 6) for [4 5 6] and CAP = 4

Examples

let mut q = DestaqueU8::<_, 4>::from([1, 2, 3]);
assert_eq![q.extend_back_override([4, 5, 6]), true];
assert_eq![q.to_array(), Some([3, 4, 5, 6])];

pub fn extend_front<I>(&mut self, iterator: I) -> Result<(), NotEnoughSpace>

where I: IntoIterator<Item = T>,

Extends the front of the destaque from an iterator.

( 1 2 -- 6 5 4 3 1 2 ) for [3 4 5 6]

Errors

Returns NotEnoughSpace if the destaque becomes full before the iterator finishes.

Examples

let mut q = DestaqueU8::<_, 6>::from([1, 2, 3]);
q.extend_front([4, 5, 6, 7, 8]);
assert_eq![q.to_array(), Some([6, 5, 4, 1, 2, 3])];

pub fn extend_front_override<I>(&mut self, iterator: I) -> bool

where I: IntoIterator<Item = T>,

Extends the front of the destaque from an iterator, overriding elements from the back if the destaque is full.

( 1 2 3 -- 6 5 4 1) for [4 5 6] and CAP = 4

Examples

let mut q = DestaqueU8::<_, 4>::from([1, 2, 3]);
assert_eq![q.extend_front_override([4, 5, 6]), true];
assert_eq![q.to_array(), Some([6, 5, 4, 1])];

impl<T: PartialEq, const CAP: usize, S: Storage> Destaque<T, CAP, u8, S>

pub fn contains(&self, element: &T) -> bool

Returns true if the destaque contains element.

Examples

let q = DestaqueU8::<_, 6>::from([5, 78, 42, 33, 9]);

assert![q.contains(&9)];
assert![!q.contains(&8)];

Trait Implementations

impl<T: Clone, const CAP: usize, IDX: Clone, S: Storage> Clone for Destaque<T, CAP, IDX, S>

where S::Stored<[T; CAP]>: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ConstInit, const CAP: usize, IDX: ConstInit> ConstInit for Destaque<T, CAP, IDX, Bare>

const INIT: Self

Returns an empty stack, allocated in the stack, using the default value to fill the remaining free data.

impl<T: Copy, const CAP: usize, IDX: Copy, S: Storage> Copy for Destaque<T, CAP, IDX, S>

where S::Stored<[T; CAP]>: Copy,

impl<T, const LEN: usize, S: Storage> DataCollection for Destaque<T, LEN, u8, S>

type Element = T

The element type of the collection.

fn collection_capacity(&self) -> Result<usize, NotAvailable>

Returns the reserved capacity for elements in the collection.

fn collection_len(&self) -> Result<usize, NotAvailable>

Returns the current number of elements in the collection.

fn collection_is_empty(&self) -> Result<bool, NotAvailable>

Returns true if the collection is empty, false if it’s not.

fn collection_is_full(&self) -> Result<bool, NotAvailable>

Returns true if the collection is full, false if it’s not.

fn collection_contains( &self, element: Self::Element, ) -> Result<bool, NotAvailable>

where T: PartialEq,

Returns true if the collection contains the given element.

fn collection_count( &self, element: &Self::Element, ) -> Result<usize, NotAvailable>

where T: PartialEq,

Counts the number of times a given element appears in the collection.

impl<T, const CAP: usize, S: Storage> DataDeque for Destaque<T, CAP, u8, S>

Available on crate feature unsafe_ptr only.

fn queue_pop_back( &mut self, ) -> Result<<Self as DataCollection>::Element, NotEnoughElements>

Remove an element from the back of the queue.

fn queue_push_front( &mut self, element: <Self as DataCollection>::Element, ) -> Result<(), NotEnoughSpace>

Add an element to the front of the queue.

fn queue_pop_front( &mut self, ) -> Result<<Self as DataCollection>::Element, NotEnoughElements>

Remove an element from the front of the queue (calls queue_pop).

fn queue_push_back( &mut self, element: <Self as DataCollection>::Element, ) -> Result<(), NotEnoughSpace>

Remove an element from the back of the queue (calls queue_push).

impl<T, const CAP: usize, S: Storage> DataDesta for Destaque<T, CAP, u8, S>

Available on crate feature unsafe_ptr only.

fn stack_pop_front( &mut self, ) -> Result<<Self as DataCollection>::Element, NotEnoughElements>

Remove an element from the front of the stack.

fn stack_push_front( &mut self, element: <Self as DataCollection>::Element, ) -> Result<(), NotEnoughSpace>

Add an element to the front of the stack.

fn stack_pop_back( &mut self, ) -> Result<<Self as DataCollection>::Element, NotEnoughElements>

Remove an element from the back of the stack (calls DataStack::stack_pop).

fn stack_push_back( &mut self, element: <Self as DataCollection>::Element, ) -> Result<(), NotEnoughSpace>

Remove an element from the back of the stack (calls DataStack::stack_push).

impl<T, const CAP: usize, S: Storage> DataQueue for Destaque<T, CAP, u8, S>

Available on crate feature unsafe_ptr only.

fn queue_pop( &mut self, ) -> Result<<Self as DataCollection>::Element, NotEnoughElements>

Remove an element from the (front of the) queue.

fn queue_push( &mut self, element: <Self as DataCollection>::Element, ) -> Result<(), NotEnoughSpace>

Add an element to the (back of the) queue.

impl<T, const CAP: usize, S: Storage> DataStack for Destaque<T, CAP, u8, S>

Available on crate feature unsafe_ptr only.

fn stack_pop( &mut self, ) -> Result<<Self as DataCollection>::Element, NotEnoughElements>

Remove an element from the (back of the) stack.

fn stack_push( &mut self, element: <Self as DataCollection>::Element, ) -> Result<(), NotEnoughSpace>

Add an element to the (back of the) stack.

impl<T: Debug, const CAP: usize, IDX: Debug, S: Storage> Debug for Destaque<T, CAP, IDX, S>

where S::Stored<[T; CAP]>: Debug,

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

Formats the value using the given formatter.

impl<T: Default, const CAP: usize, IDX: Default> Default for Destaque<T, CAP, IDX, Bare>

fn default() -> Self

Returns an empty queue, allocated in the stack, using the default value to fill the remaining free data.

impl<T: Default, const CAP: usize, IDX: Default> Default for Destaque<T, CAP, IDX, Boxed>

Available on crate feature alloc only.

fn default() -> Self

Returns an empty queue, allocated in the heap, using the default value to fill the remaining free data.

Examples

let mut q = DestaqueU8::<i32, 100, Boxed>::default();

impl<T: Eq, const CAP: usize, IDX: Eq, S: Storage> Eq for Destaque<T, CAP, IDX, S>

where S::Stored<[T; CAP]>: Eq,

impl<T: Default, I, const CAP: usize> From<I> for Destaque<T, CAP, u8, Bare>

where I: IntoIterator<Item = T>,

fn from(iterator: I) -> Destaque<T, CAP, u8, Bare>

Returns a queue filled with an iterator, in the stack.

Examples

let q: DestaqueU8<_, 3> = [1, 2, 3].into();

impl<T: Default, I, const CAP: usize> From<I> for Destaque<T, CAP, u8, Boxed>

where I: IntoIterator<Item = T>,

Available on crate feature alloc only.

fn from(iterator: I) -> Destaque<T, CAP, u8, Boxed>

Returns a queue filled with an iterator, in the heap.

Examples

let q: DestaqueU8<_, 3, Boxed> = [1, 2, 3].into();

impl<T: Ord, const CAP: usize, S: Storage> Ord for Destaque<T, CAP, u8, S>

where S::Stored<[T; CAP]>: Ord,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, const CAP: usize, IDX: PartialEq, S: Storage> PartialEq for Destaque<T, CAP, IDX, S>

where S::Stored<[T; CAP]>: PartialEq,

fn eq(&self, other: &Self) -> 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<T: PartialOrd, const CAP: usize, S: Storage> PartialOrd for Destaque<T, CAP, u8, S>

where S::Stored<[T; CAP]>: PartialOrd,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.