Struct aligned_array::Aligned

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

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::Num: IsLessOrEqual<A::Num, Output = B1>,
    N: ArrayLength<u8>,
    M: ArrayLength<u8> + PartialDiv<A2::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::Num: IsLessOrEqual<A2::Num, Output = B1>, 

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

Performs the conversion.

impl<A, N> AsNeSlice for Aligned<A, GenericArray<u8, N>> where
    A: Alignment,
    A::Num: IsGreaterOrEqual<U8, Output = B1>,
    N: ArrayLength<u8> + PartialDiv<U8>, 

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::Num: IsLessOrEqual<A2::Num, Output = B1>, 

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

Performs the conversion.

impl<A, T> Clone for Aligned<A, T> where
    A: Alignment,
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, T> Debug for Aligned<A, T> where
    A: Alignment,
    T: Debug, 

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

Formats the value using the given formatter.

impl<A, T> Default for Aligned<A, T> where
    A: Alignment,
    T: Default, 

fn default() -> Self

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

Formats the value using the given formatter.

impl<A, T> Eq for Aligned<A, T> where
    A: Alignment,
    T: Eq, 

impl<A, T, V> FromIterator<V> for Aligned<A, T> where
    A: Alignment,
    T: FromIterator<V>, 

fn from_iter<U: IntoIterator<Item = V>>(iter: U) -> Self

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 = Self

Concrete sequence type used in conjuction with reference implementations of GenericSequence

fn generate<F>(f: F) -> Self::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: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

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

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, T> IntoIterator for Aligned<A, T> where
    A: Alignment,
    T: IntoIterator, 

type Item = T::Item

The type of the elements being iterated over.

type IntoIter = T::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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) -> Self::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) -> Self::IntoIter

Creates an iterator from a value.

impl<A, T> Ord for Aligned<A, T> where
    A: Alignment,
    T: Ord, 

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<A, T> PartialEq<Aligned<A, T>> for Aligned<A, T> where
    A: Alignment,
    T: PartialEq, 

fn eq(&self, other: &Self) -> 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<A, T> PartialOrd<Aligned<A, T>> for Aligned<A, T> where
    A: Alignment,
    T: PartialOrd, 

fn partial_cmp(&self, other: &Self) -> 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, 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::Num> + 'static,
    Diff<N, K>: 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, Diff<N, K>>>

Second part of the resulting split array

fn split(self) -> (Self::First, Self::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::Num> + 'static,
    Diff<N, K>: 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, Diff<N, K>>>

Second part of the resulting split array

fn split(self) -> (Self::First, Self::Second)

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