Trait bytecheck::CheckBytes

pub trait CheckBytes<C> {
    type Error: Error + 'static;
    pub unsafe fn check_bytes<'a>(
        bytes: *const u8, 
        context: &mut C
    ) -> Result<&'a Self, Self::Error>;
}

A type that can validate whether some bytes represent a valid value.

CheckBytes can be derived with CheckBytes or implemented manually for custom behavior.

Associated Types

type Error: Error + 'static

The error that may result from validating the type.

Loading content...

Required methods

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

Checks whether the given bytes represent a valid value within the given context.

Safety

The passed pointer must be aligned and point to enough bytes to represent the type.

Loading content...

Implementations on Foreign Types

impl<C> CheckBytes<C> for ()

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for i8

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for i16

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for i32

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for i64

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for i128

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for u8

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for u16

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for u32

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for u64

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for u128

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for f32

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for f64

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for AtomicI8

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for AtomicI16

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for AtomicI32

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for AtomicI64

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for AtomicU8

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for AtomicU16

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for AtomicU32

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for AtomicU64

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for bool

type Error = BoolCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for AtomicBool

type Error = BoolCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for char

type Error = CharCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T11: CheckBytes<C>, T10: CheckBytes<C>, T9: CheckBytes<C>, T8: CheckBytes<C>, T7: CheckBytes<C>, T6: CheckBytes<C>, T5: CheckBytes<C>, T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

type Error = Tuple12CheckError<T11::Error, T10::Error, T9::Error, T8::Error, T7::Error, T6::Error, T5::Error, T4::Error, T3::Error, T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T10: CheckBytes<C>, T9: CheckBytes<C>, T8: CheckBytes<C>, T7: CheckBytes<C>, T6: CheckBytes<C>, T5: CheckBytes<C>, T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

type Error = Tuple11CheckError<T10::Error, T9::Error, T8::Error, T7::Error, T6::Error, T5::Error, T4::Error, T3::Error, T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T9: CheckBytes<C>, T8: CheckBytes<C>, T7: CheckBytes<C>, T6: CheckBytes<C>, T5: CheckBytes<C>, T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

type Error = Tuple10CheckError<T9::Error, T8::Error, T7::Error, T6::Error, T5::Error, T4::Error, T3::Error, T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T8: CheckBytes<C>, T7: CheckBytes<C>, T6: CheckBytes<C>, T5: CheckBytes<C>, T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T8, T7, T6, T5, T4, T3, T2, T1, T0)

type Error = Tuple9CheckError<T8::Error, T7::Error, T6::Error, T5::Error, T4::Error, T3::Error, T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T7: CheckBytes<C>, T6: CheckBytes<C>, T5: CheckBytes<C>, T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T7, T6, T5, T4, T3, T2, T1, T0)

type Error = Tuple8CheckError<T7::Error, T6::Error, T5::Error, T4::Error, T3::Error, T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T6: CheckBytes<C>, T5: CheckBytes<C>, T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T6, T5, T4, T3, T2, T1, T0)

type Error = Tuple7CheckError<T6::Error, T5::Error, T4::Error, T3::Error, T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T5: CheckBytes<C>, T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T5, T4, T3, T2, T1, T0)

type Error = Tuple6CheckError<T5::Error, T4::Error, T3::Error, T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T4, T3, T2, T1, T0)

type Error = Tuple5CheckError<T4::Error, T3::Error, T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T3, T2, T1, T0)

type Error = Tuple4CheckError<T3::Error, T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T2, T1, T0)

type Error = Tuple3CheckError<T2::Error, T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T1: CheckBytes<C>, T0: CheckBytes<C>, C> CheckBytes<C> for (T1, T0)

type Error = Tuple2CheckError<T1::Error, T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T0: CheckBytes<C>, C> CheckBytes<C> for (T0,)

type Error = Tuple1CheckError<T0::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 31]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 30]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 29]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 28]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 27]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 26]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 25]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 24]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 23]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 22]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 21]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 20]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 19]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 18]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 17]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 16]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 15]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 14]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 13]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 12]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 11]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 10]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 9]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 8]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 7]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 6]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 5]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 4]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 3]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 2]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 1]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for [T; 0]

type Error = ArrayCheckError<T::Error>

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for Range<T>

type Error = StructCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for RangeFrom<T>

type Error = StructCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for RangeFull

type Error = Unreachable

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    _context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for RangeTo<T>

type Error = StructCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: CheckBytes<C>, C> CheckBytes<C> for RangeToInclusive<T>

type Error = StructCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroI8

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroI16

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroI32

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroI64

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroI128

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroU8

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroU16

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroU32

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroU64

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

impl<C> CheckBytes<C> for NonZeroU128

type Error = NonZeroCheckError

pub unsafe fn check_bytes<'a>(
    bytes: *const u8,
    context: &mut C
) -> Result<&'a Self, Self::Error>

Loading content...

Implementors

Loading content...