Trait bytecheck::CheckBytes

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

A type that can check whether a pointer points to 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 checking the type.

Required methods

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

Checks whether the given pointer points to a valid value within the given context.

Safety

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

Implementations on Foreign Types

impl<C: ?Sized> CheckBytes<C> for ()

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for i8

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for i16

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for i32

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for i64

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for i128

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for u8

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for u16

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for u32

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for u64

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for u128

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for f32

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for f64

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for AtomicI8

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for AtomicI16

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for AtomicI32

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for AtomicI64

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for AtomicU8

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for AtomicU16

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for AtomicU32

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for AtomicU64

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<T: ?Sized, C: ?Sized> CheckBytes<C> for PhantomData<T>

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for PhantomPinned

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for bool

type Error = BoolCheckError

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for AtomicBool

type Error = BoolCheckError

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

impl<C: ?Sized> CheckBytes<C> for char

type Error = CharCheckError

unsafe fn check_bytes<'a>(
    value: *const Self,
    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: ?Sized> 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>

unsafe fn check_bytes<'a>(
    value: *const Self,
    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: ?Sized> 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>

unsafe fn check_bytes<'a>(
    value: *const Self,
    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: ?Sized> 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>

unsafe fn check_bytes<'a>(
    value: *const Self,
    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: ?Sized> 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>

unsafe fn check_bytes<'a>(
    value: *const Self,
    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: ?Sized> 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>

unsafe fn check_bytes<'a>(
    value: *const Self,
    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: ?Sized> 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>

unsafe fn check_bytes<'a>(
    value: *const Self,
    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: ?Sized> CheckBytes<C> for (T5, T4, T3, T2, T1, T0)

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

unsafe fn check_bytes<'a>(
    value: *const Self,
    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: ?Sized> CheckBytes<C> for (T4, T3, T2, T1, T0)

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

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

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

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

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

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

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

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

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

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

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

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

type Error = Tuple1CheckError<T0::Error>

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

impl<T: CheckBytes<C>, C: ?Sized, const N: usize> CheckBytes<C> for [T; N]

type Error = ArrayCheckError<T::Error>

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

impl<T: CheckBytes<C>, C: ?Sized> CheckBytes<C> for [T]

type Error = SliceCheckError<T::Error>

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

impl<C: ?Sized> CheckBytes<C> for str

type Error = StrCheckError

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

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

type Error = StructCheckError

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

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

type Error = StructCheckError

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

impl<C: ?Sized> CheckBytes<C> for RangeFull

type Error = Infallible

unsafe fn check_bytes<'a>(
    value: *const Self,
    _: &mut C
) -> Result<&'a Self, Self::Error>

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

type Error = StructCheckError

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

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

type Error = StructCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroI8

type Error = NonZeroCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroI16

type Error = NonZeroCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroI32

type Error = NonZeroCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroI64

type Error = NonZeroCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroI128

type Error = NonZeroCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroU8

type Error = NonZeroCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroU16

type Error = NonZeroCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroU32

type Error = NonZeroCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroU64

type Error = NonZeroCheckError

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

impl<C: ?Sized> CheckBytes<C> for NonZeroU128

type Error = NonZeroCheckError

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

Implementors