Trait FromSized 

pub trait FromSized: Size<Size: ArrayLength> {
    // Required method
    fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self;
}

Required Methods

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl FromSized for ()

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl FromSized for u8

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, D, E, F, G, H, I, J, K, L, N> FromSized for (A, B, C, D, E, F, G, H, I, J, K, L)

where (A, (B, C, D, E, F, G, H, I, J, K, L)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, D, E, F, G, H, I, J, K, N> FromSized for (A, B, C, D, E, F, G, H, I, J, K)

where (A, (B, C, D, E, F, G, H, I, J, K)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, D, E, F, G, H, I, J, N> FromSized for (A, B, C, D, E, F, G, H, I, J)

where (A, (B, C, D, E, F, G, H, I, J)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, D, E, F, G, H, I, N> FromSized for (A, B, C, D, E, F, G, H, I)

where (A, (B, C, D, E, F, G, H, I)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, D, E, F, G, H, N> FromSized for (A, B, C, D, E, F, G, H)

where (A, (B, C, D, E, F, G, H)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, D, E, F, G, N> FromSized for (A, B, C, D, E, F, G)

where (A, (B, C, D, E, F, G)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, D, E, F, N> FromSized for (A, B, C, D, E, F)

where (A, (B, C, D, E, F)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, D, E, N> FromSized for (A, B, C, D, E)

where (A, (B, C, D, E)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, D, N> FromSized for (A, B, C, D)

where (A, (B, C, D)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A, B, C, N> FromSized for (A, B, C)

where (A, (B, C)): FromSized<Size = N>, Self: Size<Size = N>,

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

impl<A: FromSized<Size = An>, B: FromSized<Size = Bn>, An, Bn: Add<An, Output: ArrayLength + Sub<An, Output = Bn>>> FromSized for (A, B)

fn from_sized(data: &GenericArray<u8, Self::Size>) -> Self

Implementors

impl<M> FromSized for SmExtra<M>