Struct Aligned

#[repr(C)]
pub struct Aligned<A, T>
where
    T: ?Sized,
{ /* private fields */ }

A newtype with alignment of at least A bytes

Trait Implementations

impl<A, A2, N, M> AsAlignedChunks<A2, M> for Aligned<A, GenericArray<u8, N>>

where A: Alignment, A2: Alignment, <A2 as Alignment>::Num: IsLessOrEqual<<A as Alignment>::Num, Output = B1>, N: ArrayLength<u8>, M: ArrayLength<u8> + PartialDiv<<A2 as Alignment>::Num>,

fn as_aligned_chunks(&self) -> &[Aligned<A2, GenericArray<u8, M>>]

Break self into aligned chunks of size M. This is not required to cover all the bytes of Self, trailing bytes that don’t fit may be left off.

fn as_mut_aligned_chunks(&mut self) -> &mut [Aligned<A2, GenericArray<u8, M>>]

Break self into mutable aligned chunks of size M. This is not required to cover all the bytes of Self, but must agree with as_aligned_chunks.

impl<'a, A, A2, T> AsMut<Aligned<A, T>> for &'a mut Aligned<A2, T>

where A: Alignment, A2: Alignment, <A as Alignment>::Num: IsLessOrEqual<<A2 as Alignment>::Num, Output = B1>,

fn as_mut(&mut self) -> &mut Aligned<A, T>

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

impl<A, N> AsNeSlice for Aligned<A, GenericArray<u8, N>>

where A: Alignment, <A as Alignment>::Num: IsGreaterOrEqual<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, Output = B1>, N: ArrayLength<u8> + PartialDiv<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>,

fn as_ne_u16_slice(&self) -> &[u16]

Represent the value as native-endian u16’s

fn as_mut_ne_u16_slice(&mut self) -> &mut [u16]

Represent the value as mutable native-endian u16’s

fn as_ne_u32_slice(&self) -> &[u32]

Represent the value as native-endian u32’s

fn as_mut_ne_u32_slice(&mut self) -> &mut [u32]

Represent the value as mutable native-endian u32’s

fn as_ne_u64_slice(&self) -> &[u64]

Represent the value as native-endian u64’s

fn as_mut_ne_u64_slice(&mut self) -> &mut [u64]

Represent the value as mutable native-endian u64’s

impl<'a, A, A2, T> AsRef<Aligned<A, T>> for &'a Aligned<A2, T>

where A: Alignment, A2: Alignment, <A as Alignment>::Num: IsLessOrEqual<<A2 as Alignment>::Num, Output = B1>,

fn as_ref(&self) -> &Aligned<A, T>

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

impl<A, T> Clone for Aligned<A, T>

where A: Alignment, T: Clone,

fn clone(&self) -> Aligned<A, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, N> ConstantTimeEq for Aligned<A, GenericArray<u8, N>>

where A: Alignment, <A as Alignment>::Num: IsGreaterOrEqual<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, Output = B1>, N: ArrayLength<u8> + PartialDiv<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>,

Implement ct_eq for Aligned bytes implementing AsNeSlice

Typically to invoke ct_eq on Aligned<T> you can * it to remove the aligned wrapper and then invoke ct_eq, there is no special implementation.

In some cases, like aligned bytes, CtEq can be made faster by operating on 8 bytes at once, and it’s nice to take advantage of that.

fn ct_eq(&self, other: &Aligned<A, GenericArray<u8, N>>) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<A, T> Debug for Aligned<A, T>

where A: Alignment, T: Debug,

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

Formats the value using the given formatter.

impl<A, T> Default for Aligned<A, T>

where A: Alignment, T: Default,

fn default() -> Aligned<A, T>

Returns the “default value” for a type.

impl<A, T> Deref for Aligned<A, T>

where A: Alignment, T: ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<A, T> DerefMut for Aligned<A, T>

where A: Alignment, T: ?Sized,

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<A, T> Display for Aligned<A, T>

where A: Alignment, T: Display,

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

Formats the value using the given formatter.

impl<A, T, V> FromIterator<V> for Aligned<A, T>

where A: Alignment, T: FromIterator<V>,

fn from_iter<U>(iter: U) -> Aligned<A, T>

where U: IntoIterator<Item = V>,

Creates a value from an iterator.

impl<A, T, N> GenericSequence<T> for Aligned<A, GenericArray<T, N>>

where N: ArrayLength<T>, A: Alignment,

Implement generic_array::GenericSequence for Aligned sequences

type Length = N

GenericArray associated length

type Sequence = Aligned<A, GenericArray<T, N>>

Concrete sequence type used in conjuction with reference implementations of GenericSequence

fn generate<F>( f: F, ) -> <Aligned<A, GenericArray<T, N>> as GenericSequence<T>>::Sequence

where F: FnMut(usize) -> T,

Initializes a new sequence instance using the given function.

impl<A, T> Hash for Aligned<A, T>

where A: Alignment, T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A, T> Index<RangeTo<usize>> for Aligned<A, [T]>

where A: Alignment,

type Output = Aligned<A, [T]>

The returned type after indexing.

fn index(&self, range: RangeTo<usize>) -> &Aligned<A, [T]>

Performs the indexing (container[index]) operation.

impl<'a, A, T> IntoIterator for &'a Aligned<A, T>

where A: Alignment, &'a T: IntoIterator,

type Item = <&'a T as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a T as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Aligned<A, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, A, T> IntoIterator for &'a mut Aligned<A, T>

where A: Alignment, &'a mut T: IntoIterator,

type Item = <&'a mut T as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a mut T as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut Aligned<A, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<A, T> IntoIterator for Aligned<A, T>

where A: Alignment, T: IntoIterator,

type Item = <T as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <T as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Aligned<A, T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<A, T> Ord for Aligned<A, T>

where A: Alignment, T: Ord,

fn cmp(&self, other: &Aligned<A, T>) -> 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<A, T> PartialEq for Aligned<A, T>

where A: Alignment, T: PartialEq,

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

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

const 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<A, T> PartialOrd for Aligned<A, T>

where A: Alignment, T: PartialOrd,

fn partial_cmp(&self, other: &Aligned<A, T>) -> 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.

impl<'a, A, N, K> Split<u8, K> for &'a Aligned<A, GenericArray<u8, N>>

where A: Alignment, N: ArrayLength<u8> + Sub<K>, K: ArrayLength<u8> + PartialDiv<<A as Alignment>::Num> + 'static, <N as Sub<K>>::Output: ArrayLength<u8>,

Implement generic_array::Split api for aligned bytes in a way that preserves aligment info TODO: This could be more generic, but we didn’t need it yet. Instead of u8, a generic value T?

type First = &'a Aligned<A, GenericArray<u8, K>>

First part of the resulting split array

type Second = &'a Aligned<A, GenericArray<u8, <N as Sub<K>>::Output>>

Second part of the resulting split array

fn split( self, ) -> (<&'a Aligned<A, GenericArray<u8, N>> as Split<u8, K>>::First, <&'a Aligned<A, GenericArray<u8, N>> as Split<u8, K>>::Second)

Splits an array at the given index, returning the separate parts of the array.

impl<'a, A, N, K> Split<u8, K> for &'a mut Aligned<A, GenericArray<u8, N>>

where A: Alignment, N: ArrayLength<u8> + Sub<K>, K: ArrayLength<u8> + PartialDiv<<A as Alignment>::Num> + 'static, <N as Sub<K>>::Output: ArrayLength<u8>,

Implement generic_array::Split API for aligned bytes in a way that preserves aligment info TODO: This could be more generic, but we didn’t need it yet. Instead of u8, a generic value T?

type First = &'a mut Aligned<A, GenericArray<u8, K>>

First part of the resulting split array

type Second = &'a mut Aligned<A, GenericArray<u8, <N as Sub<K>>::Output>>

Second part of the resulting split array

fn split( self, ) -> (<&'a mut Aligned<A, GenericArray<u8, N>> as Split<u8, K>>::First, <&'a mut Aligned<A, GenericArray<u8, N>> as Split<u8, K>>::Second)

Splits an array at the given index, returning the separate parts of the array.

impl<A, T> Eq for Aligned<A, T>

where A: Alignment, T: Eq,