Trait byte_slice_cast::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

Object Safety

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