Struct rsa_cortex_m4::numbers::Array

#[repr(C)]pub struct Array<const D: usize, const E: usize, const L: usize> { /* fields omitted */ }

Array of Unsigned.

Implementations

impl<const D: usize, const E: usize, const L: usize> Array<D, E, L>

pub fn wrapping_sub_assign<T: Number>(&mut self, subtrahend: &T)

impl<const D: usize> Array<D, E, 2_usize>

pub fn into_long(self) -> Long<D>

pub fn as_long(&self) -> &Long<D>

impl<const D: usize, const E: usize, const L: usize> Array<D, E, L>

Trait methods as inherent methods, for convenience.

pub fn from_slice(slice: &[Digit]) -> Self

pub fn try_from_slice(slice: &[Digit]) -> Result<Self>

pub fn leading_digit(&self) -> Option<Digit>

pub fn significant_digits(&self) -> &[Digit]

pub fn to_unsigned<const M: usize, const N: usize>(
    &self
) -> Result<Unsigned<M, N>>

impl<const D: usize, const E: usize, const L: usize> Array<D, E, L>

pub fn to_bytes(&self) -> BigEndian<D, E, L>

Return buffer that dereferences as big-endian bytes.

Trait Implementations

impl<const D: usize, const E: usize, const L: usize> Clone for Array<D, E, L>

fn clone(&self) -> Array<D, E, L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const D: usize, const E: usize, const L: usize> Debug for Array<D, E, L>

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

TODO: Do we want debug output to be big-endian bytes (as currently implemented)? Or stick with internal representation?

impl<const D: usize, const E: usize, const L: usize> Default for Array<D, E, L>

fn default() -> Self

Returns the "default value" for a type.

impl<const D: usize, const E: usize, const L: usize> Deref for Array<D, E, L>

type Target = [Digit]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<const D: usize, const E: usize, const L: usize> DerefMut for Array<D, E, L>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<const D: usize, const E: usize, const L: usize> Eq for Array<D, E, L>

impl<const D: usize, const E: usize, const L: usize> Number for Array<D, E, L>

const BITS: usize

The number of bits that fit in this number.

const DIGITS: usize

The number of digits that fit in this number.

fn significant_digits(&self) -> &[Digit]

The significant digits of the number (little-endian).

fn leading_digit(&self) -> Option<Digit>

The last non-zero digit of the number.

fn to_unsigned<const D: usize, const E: usize>(&self) -> Result<Unsigned<D, E>>

Embed in number with D + E digits, if possible.

fn zero() -> Self

fn is_zero(&self) -> bool

fn is_one(&self) -> bool

fn is_digit(&self) -> bool

fn is_odd(&self) -> bool

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

This is little endian ordering, as opposed to the default ordering on arrays and slices!

fn eq(&self, other: &impl Number) -> bool

fn deref(&self) -> &[Digit]

fn deref_mut(&mut self) -> &mut Self::Target

impl<const D: usize, const E: usize, const L: usize> NumberMut for Array<D, E, L>

fn from_slice(slice: &[Digit]) -> Self

fn try_from_slice(slice: &[Digit]) -> Result<Self>

fn from_bytes(bytes: &[u8]) -> Self

fn set_zero(&mut self)

fn one() -> Self

fn swap_order(self) -> Self

Swap endianness of digits in Self and, if the platform is little-endian, endianness of bytes within digits.

fn random(rng: impl CryptoRng + RngCore) -> Self

impl<T, const D: usize, const E: usize, const L: usize> PartialEq<T> for Array<D, E, L> where
    T: Number, 

fn eq(&self, other: &T) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, const D: usize, const E: usize, const L: usize> PartialOrd<T> for Array<D, E, L> where
    T: Number, 

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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

impl<'a, const D: usize, const E: usize, const F: usize, const G: usize, const L: usize> Rem<&'a Unsigned<F, G>> for &'a Array<D, E, L>

type Output = Unsigned<F, G>

The resulting type after applying the % operator.

fn rem(self, modulus: &'a Unsigned<F, G>) -> Self::Output

Performs the % operation.

impl<const D: usize, const E: usize, const L: usize> Shl<usize> for &Array<D, E, L>

type Output = Array<D, E, L>

The resulting type after applying the << operator.

fn shl(self, bits: usize) -> Self::Output

Performs the << operation.

impl<const D: usize, const E: usize, const L: usize> ShlAssign<usize> for Array<D, E, L>

fn shl_assign(&mut self, bits: usize)

Performs the <<= operation.

impl<const D: usize, const E: usize, const L: usize> Shr<usize> for &Array<D, E, L>

type Output = Array<D, E, L>

The resulting type after applying the >> operator.

fn shr(self, bits: usize) -> Self::Output

Performs the >> operation.

impl<const D: usize, const E: usize, const L: usize> ShrAssign<usize> for Array<D, E, L>

fn shr_assign(&mut self, bits: usize)

Performs the >>= operation.

impl<const D: usize, const E: usize, const L: usize> StructuralEq for Array<D, E, L>