Trait FromByteSlice

pub unsafe trait FromByteSlice
where
    Self: Sized,
{
    // Required methods
    fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(
        slice: &T,
    ) -> Result<&[Self], Error>;
    fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>(
        slice: &mut T,
    ) -> Result<&mut [Self], Error>;
}

Trait for converting from a byte slice to a slice of a fundamental, built-in numeric type.

This trait is an implementation detail. Use the AsSliceOf and AsMutSliceOf traits.

Required Methods

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[Self], Error>

Convert from an immutable byte slice to a immutable slice of a fundamental, built-in numeric type

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [Self], Error>

Convert from an mutable byte slice to a mutable slice of a fundamental, built-in numeric type

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl FromByteSlice for f32

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[f32], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [f32], Error>

impl FromByteSlice for f64

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[f64], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [f64], Error>

impl FromByteSlice for i8

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[i8], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [i8], Error>

impl FromByteSlice for i16

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[i16], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [i16], Error>

impl FromByteSlice for i32

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[i32], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [i32], Error>

impl FromByteSlice for i64

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[i64], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [i64], Error>

impl FromByteSlice for i128

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[i128], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [i128], Error>

impl FromByteSlice for isize

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[isize], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [isize], Error>

impl FromByteSlice for u8

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[u8], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [u8], Error>

impl FromByteSlice for u16

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[u16], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [u16], Error>

impl FromByteSlice for u32

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[u32], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [u32], Error>

impl FromByteSlice for u64

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[u64], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [u64], Error>

impl FromByteSlice for u128

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>(slice: &T) -> Result<&[u128], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [u128], Error>

impl FromByteSlice for usize

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[usize], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [usize], Error>

impl<const N: usize> FromByteSlice for [f32; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[f32; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[f32; N]], Error>

impl<const N: usize> FromByteSlice for [f64; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[f64; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[f64; N]], Error>

impl<const N: usize> FromByteSlice for [i8; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[i8; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[i8; N]], Error>

impl<const N: usize> FromByteSlice for [i16; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[i16; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[i16; N]], Error>

impl<const N: usize> FromByteSlice for [i32; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[i32; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[i32; N]], Error>

impl<const N: usize> FromByteSlice for [i64; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[i64; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[i64; N]], Error>

impl<const N: usize> FromByteSlice for [i128; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[i128; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[i128; N]], Error>

impl<const N: usize> FromByteSlice for [isize; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[isize; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[isize; N]], Error>

impl<const N: usize> FromByteSlice for [u8; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[u8; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[u8; N]], Error>

impl<const N: usize> FromByteSlice for [u16; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[u16; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[u16; N]], Error>

impl<const N: usize> FromByteSlice for [u32; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[u32; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[u32; N]], Error>

impl<const N: usize> FromByteSlice for [u64; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[u64; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[u64; N]], Error>

impl<const N: usize> FromByteSlice for [u128; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[u128; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[u128; N]], Error>

impl<const N: usize> FromByteSlice for [usize; N]

fn from_byte_slice<T: AsRef<[u8]> + ?Sized>( slice: &T, ) -> Result<&[[usize; N]], Error>

fn from_mut_byte_slice<T: AsMut<[u8]> + ?Sized>( slice: &mut T, ) -> Result<&mut [[usize; N]], Error>

Implementors