Struct ComparableArray

pub struct ComparableArray<'a, T, const N: usize>
where
    T: PartialEq,
{ /* private fields */ }

Comparable array of variables.

This can be used when manually calling is_buffer_equal to compare two arrays is to be avoided.

Using ComparableArray over is_buffer_equal is generally preferred, since it is more readable.

Example

const A: &[u8; 14] = b"same same same";
const B: &[u8; 14] = b"same same same";

const COMPARABLE_A: ComparableArray<u8, 14> = ComparableArray::new(A);
const COMPARABLE_B: ComparableArray<u8, 14> = ComparableArray::new(B);

if COMPARABLE_A != COMPARABLE_B {
    rollback(b"arrays are not the same", -1);
}

Implementations

impl<'a, T: PartialEq, const N: usize> ComparableArray<'a, T, N>

pub const fn new(data: &'a [T; N]) -> Self

Create a new ComparableArray

Trait Implementations

impl<T: PartialEq, const N: usize> AsRef<[T]> for ComparableArray<'_, T, N>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, T, const N: usize> From<&'a [T; N]> for ComparableArray<'a, T, N>

where T: PartialEq,

fn from(data: &'a [T; N]) -> Self

Converts to this type from the input type.

impl<T, const N: usize> PartialEq for ComparableArray<'_, T, N>

where T: 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.