Trait CheckBytes

pub trait CheckBytes<C>
where
    C: ?Sized,
{
    type Error: Error + 'static;

    // Required method
    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.

Required 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.

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<C> CheckBytes<C> for bool

where C: ?Sized,

type Error = BoolCheckError

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

impl<C> CheckBytes<C> for char

where C: ?Sized,

type Error = CharCheckError

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

impl<C> CheckBytes<C> for f32

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for f64

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for i8

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for i16

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for i32

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for i64

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for i128

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for str

where C: ?Sized,

type Error = StrCheckError

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

impl<C> CheckBytes<C> for u8

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for u16

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for u32

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for u64

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for u128

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for ()

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<char>

where C: ?Sized,

type Error = CharCheckError

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

impl<C> CheckBytes<C> for BigEndian<f32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<f64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<i16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<i32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<i64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<i128>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<u16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<u32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<u64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<u128>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<NonZero<i16>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const BigEndian<NonZero<i16>>, context: &mut C, ) -> Result<&'a BigEndian<NonZero<i16>>, <BigEndian<NonZero<i16>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for BigEndian<NonZero<i32>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const BigEndian<NonZero<i32>>, context: &mut C, ) -> Result<&'a BigEndian<NonZero<i32>>, <BigEndian<NonZero<i32>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for BigEndian<NonZero<i64>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const BigEndian<NonZero<i64>>, context: &mut C, ) -> Result<&'a BigEndian<NonZero<i64>>, <BigEndian<NonZero<i64>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for BigEndian<NonZero<i128>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const BigEndian<NonZero<i128>>, context: &mut C, ) -> Result<&'a BigEndian<NonZero<i128>>, <BigEndian<NonZero<i128>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for BigEndian<NonZero<u16>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const BigEndian<NonZero<u16>>, context: &mut C, ) -> Result<&'a BigEndian<NonZero<u16>>, <BigEndian<NonZero<u16>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for BigEndian<NonZero<u32>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const BigEndian<NonZero<u32>>, context: &mut C, ) -> Result<&'a BigEndian<NonZero<u32>>, <BigEndian<NonZero<u32>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for BigEndian<NonZero<u64>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const BigEndian<NonZero<u64>>, context: &mut C, ) -> Result<&'a BigEndian<NonZero<u64>>, <BigEndian<NonZero<u64>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for BigEndian<NonZero<u128>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const BigEndian<NonZero<u128>>, context: &mut C, ) -> Result<&'a BigEndian<NonZero<u128>>, <BigEndian<NonZero<u128>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for BigEndian<AtomicI16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<AtomicI32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<AtomicI64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<AtomicU16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<AtomicU32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for BigEndian<AtomicU64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<char>

where C: ?Sized,

type Error = CharCheckError

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

impl<C> CheckBytes<C> for LittleEndian<f32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<f64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<i16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<i32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<i64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<i128>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<u16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<u32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<u64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<u128>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<NonZero<i16>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const LittleEndian<NonZero<i16>>, context: &mut C, ) -> Result<&'a LittleEndian<NonZero<i16>>, <LittleEndian<NonZero<i16>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for LittleEndian<NonZero<i32>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const LittleEndian<NonZero<i32>>, context: &mut C, ) -> Result<&'a LittleEndian<NonZero<i32>>, <LittleEndian<NonZero<i32>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for LittleEndian<NonZero<i64>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const LittleEndian<NonZero<i64>>, context: &mut C, ) -> Result<&'a LittleEndian<NonZero<i64>>, <LittleEndian<NonZero<i64>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for LittleEndian<NonZero<i128>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const LittleEndian<NonZero<i128>>, context: &mut C, ) -> Result<&'a LittleEndian<NonZero<i128>>, <LittleEndian<NonZero<i128>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for LittleEndian<NonZero<u16>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const LittleEndian<NonZero<u16>>, context: &mut C, ) -> Result<&'a LittleEndian<NonZero<u16>>, <LittleEndian<NonZero<u16>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for LittleEndian<NonZero<u32>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const LittleEndian<NonZero<u32>>, context: &mut C, ) -> Result<&'a LittleEndian<NonZero<u32>>, <LittleEndian<NonZero<u32>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for LittleEndian<NonZero<u64>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const LittleEndian<NonZero<u64>>, context: &mut C, ) -> Result<&'a LittleEndian<NonZero<u64>>, <LittleEndian<NonZero<u64>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for LittleEndian<NonZero<u128>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const LittleEndian<NonZero<u128>>, context: &mut C, ) -> Result<&'a LittleEndian<NonZero<u128>>, <LittleEndian<NonZero<u128>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for LittleEndian<AtomicI16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<AtomicI32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<AtomicI64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<AtomicU16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<AtomicU32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for LittleEndian<AtomicU64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<char>

where C: ?Sized,

type Error = CharCheckError

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

impl<C> CheckBytes<C> for NativeEndian<f32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<f64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<i16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<i32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<i64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<i128>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<u16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<u32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<u64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<u128>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<NonZero<i16>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const NativeEndian<NonZero<i16>>, context: &mut C, ) -> Result<&'a NativeEndian<NonZero<i16>>, <NativeEndian<NonZero<i16>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for NativeEndian<NonZero<i32>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const NativeEndian<NonZero<i32>>, context: &mut C, ) -> Result<&'a NativeEndian<NonZero<i32>>, <NativeEndian<NonZero<i32>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for NativeEndian<NonZero<i64>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const NativeEndian<NonZero<i64>>, context: &mut C, ) -> Result<&'a NativeEndian<NonZero<i64>>, <NativeEndian<NonZero<i64>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for NativeEndian<NonZero<i128>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const NativeEndian<NonZero<i128>>, context: &mut C, ) -> Result<&'a NativeEndian<NonZero<i128>>, <NativeEndian<NonZero<i128>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for NativeEndian<NonZero<u16>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const NativeEndian<NonZero<u16>>, context: &mut C, ) -> Result<&'a NativeEndian<NonZero<u16>>, <NativeEndian<NonZero<u16>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for NativeEndian<NonZero<u32>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const NativeEndian<NonZero<u32>>, context: &mut C, ) -> Result<&'a NativeEndian<NonZero<u32>>, <NativeEndian<NonZero<u32>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for NativeEndian<NonZero<u64>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const NativeEndian<NonZero<u64>>, context: &mut C, ) -> Result<&'a NativeEndian<NonZero<u64>>, <NativeEndian<NonZero<u64>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for NativeEndian<NonZero<u128>>

where C: ?Sized,

type Error = NonZeroCheckError

unsafe fn check_bytes<'a>( value: *const NativeEndian<NonZero<u128>>, context: &mut C, ) -> Result<&'a NativeEndian<NonZero<u128>>, <NativeEndian<NonZero<u128>> as CheckBytes<C>>::Error>

impl<C> CheckBytes<C> for NativeEndian<AtomicI16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<AtomicI32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<AtomicI64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<AtomicU16>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<AtomicU32>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NativeEndian<AtomicU64>

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for CStr

where C: ?Sized,

type Error = CStrCheckError

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

impl<C> CheckBytes<C> for PhantomPinned

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for NonZero<i8>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for NonZero<i16>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for NonZero<i32>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for NonZero<i64>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for NonZero<i128>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for NonZero<u8>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for NonZero<u16>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for NonZero<u32>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for NonZero<u64>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for NonZero<u128>

where C: ?Sized,

type Error = NonZeroCheckError

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

impl<C> CheckBytes<C> for RangeFull

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for AtomicBool

where C: ?Sized,

type Error = BoolCheckError

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

impl<C> CheckBytes<C> for AtomicI8

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for AtomicI16

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for AtomicI32

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for AtomicI64

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for AtomicU8

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for AtomicU16

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for AtomicU32

where C: ?Sized,

type Error = Infallible

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

impl<C> CheckBytes<C> for AtomicU64

where C: ?Sized,

type Error = Infallible

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

impl<C, T> CheckBytes<C> for ManuallyDrop<T>

where T: CheckBytes<C> + ?Sized, C: ?Sized,

type Error = <T as CheckBytes<C>>::Error

unsafe fn check_bytes<'a>( value: *const ManuallyDrop<T>, c: &mut C, ) -> Result<&'a ManuallyDrop<T>, <ManuallyDrop<T> as CheckBytes<C>>::Error>

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

where T0: CheckBytes<C>, C: ?Sized,

type Error = Tuple1CheckError<<T0 as CheckBytes<C>>::Error>

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

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

where T1: CheckBytes<C>, T0: CheckBytes<C>, C: ?Sized,

type Error = Tuple2CheckError<<T1 as CheckBytes<C>>::Error, <T0 as CheckBytes<C>>::Error>

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

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

where T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C: ?Sized,

type Error = Tuple3CheckError<<T2 as CheckBytes<C>>::Error, <T1 as CheckBytes<C>>::Error, <T0 as CheckBytes<C>>::Error>

unsafe fn check_bytes<'a>( value: *const (T2, T1, T0), context: &mut C, ) -> Result<&'a (T2, T1, T0), <(T2, T1, T0) as CheckBytes<C>>::Error>

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

where T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C: ?Sized,

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

unsafe fn check_bytes<'a>( value: *const (T3, T2, T1, T0), context: &mut C, ) -> Result<&'a (T3, T2, T1, T0), <(T3, T2, T1, T0) as CheckBytes<C>>::Error>

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

where T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C: ?Sized,

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

unsafe fn check_bytes<'a>( value: *const (T4, T3, T2, T1, T0), context: &mut C, ) -> Result<&'a (T4, T3, T2, T1, T0), <(T4, T3, T2, T1, T0) as CheckBytes<C>>::Error>

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

where T5: CheckBytes<C>, T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C: ?Sized,

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

unsafe fn check_bytes<'a>( value: *const (T5, T4, T3, T2, T1, T0), context: &mut C, ) -> Result<&'a (T5, T4, T3, T2, T1, T0), <(T5, T4, T3, T2, T1, T0) as CheckBytes<C>>::Error>

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

where T6: CheckBytes<C>, T5: CheckBytes<C>, T4: CheckBytes<C>, T3: CheckBytes<C>, T2: CheckBytes<C>, T1: CheckBytes<C>, T0: CheckBytes<C>, C: ?Sized,

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

unsafe fn check_bytes<'a>( value: *const (T6, T5, T4, T3, T2, T1, T0), context: &mut C, ) -> Result<&'a (T6, T5, T4, T3, T2, T1, T0), <(T6, T5, T4, T3, T2, T1, T0) as CheckBytes<C>>::Error>

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

where 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,

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

unsafe fn check_bytes<'a>( value: *const (T7, T6, T5, T4, T3, T2, T1, T0), context: &mut C, ) -> Result<&'a (T7, T6, T5, T4, T3, T2, T1, T0), <(T7, T6, T5, T4, T3, T2, T1, T0) as CheckBytes<C>>::Error>

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

where 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,

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

unsafe fn check_bytes<'a>( value: *const (T8, T7, T6, T5, T4, T3, T2, T1, T0), context: &mut C, ) -> Result<&'a (T8, T7, T6, T5, T4, T3, T2, T1, T0), <(T8, T7, T6, T5, T4, T3, T2, T1, T0) as CheckBytes<C>>::Error>

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

where 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,

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

unsafe fn check_bytes<'a>( value: *const (T9, T8, T7, T6, T5, T4, T3, T2, T1, T0), context: &mut C, ) -> Result<&'a (T9, T8, T7, T6, T5, T4, T3, T2, T1, T0), <(T9, T8, T7, T6, T5, T4, T3, T2, T1, T0) as CheckBytes<C>>::Error>

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

where 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,

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

unsafe fn check_bytes<'a>( value: *const (T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0), context: &mut C, ) -> Result<&'a (T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0), <(T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0) as CheckBytes<C>>::Error>

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

where 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,

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

unsafe fn check_bytes<'a>( value: *const (T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0), context: &mut C, ) -> Result<&'a (T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0), <(T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0) as CheckBytes<C>>::Error>

impl<T, C> CheckBytes<C> for [T]

where T: CheckBytes<C>, C: ?Sized,

type Error = SliceCheckError<<T as CheckBytes<C>>::Error>

unsafe fn check_bytes<'a>( value: *const [T], context: &mut C, ) -> Result<&'a [T], <[T] as CheckBytes<C>>::Error>

impl<T, C> CheckBytes<C> for PhantomData<T>

where T: ?Sized, C: ?Sized,

type Error = Infallible

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

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

where T: CheckBytes<C>, C: ?Sized,

type Error = StructCheckError

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

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

where T: CheckBytes<C>, C: ?Sized,

type Error = StructCheckError

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

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

where T: CheckBytes<C>, C: ?Sized,

type Error = StructCheckError

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

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

where T: CheckBytes<C>, C: ?Sized,

type Error = StructCheckError

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

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

where T: CheckBytes<C>, C: ?Sized,

type Error = ArrayCheckError<<T as CheckBytes<C>>::Error>

unsafe fn check_bytes<'a>( value: *const [T; N], context: &mut C, ) -> Result<&'a [T; N], <[T; N] as CheckBytes<C>>::Error>

Implementors

impl<C: Fallible + ?Sized> CheckBytes<C> for ArchivedDuration

type Error = DurationError

impl<C: Fallible + ?Sized> CheckBytes<C> for ArchivedStringRepr

type Error = CheckStringReprError

impl<C: ArchiveContext + ?Sized> CheckBytes<C> for ArchivedHashIndex

where C::Error: Error,

type Error = HashIndexError<<C as Fallible>::Error>

impl<C: ArchiveContext + ?Sized> CheckBytes<C> for ArchivedCString

where C::Error: Error,

type Error = OwnedPointerError<<<CStr as ArchivePointee>::ArchivedMetadata as CheckBytes<C>>::Error, <CStr as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<C: ArchiveContext + ?Sized> CheckBytes<C> for ArchivedString

where C::Error: Error + 'static,

type Error = OwnedPointerError<<ArchivedStringRepr as CheckBytes<C>>::Error, <str as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<K, V, C> CheckBytes<C> for ArchivedBTreeMap<K, V>

where K: CheckBytes<C> + Ord, V: CheckBytes<C>, C: ArchiveContext + ?Sized, C::Error: Error,

type Error = ArchivedBTreeMapError<<K as CheckBytes<C>>::Error, <V as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<K, V, C> CheckBytes<C> for ArchivedHashMap<K, V>

where K: CheckBytes<C> + Eq + Hash, V: CheckBytes<C>, C: ArchiveContext + ?Sized, C::Error: Error,

type Error = HashMapError<<K as CheckBytes<C>>::Error, <V as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<K, V, C> CheckBytes<C> for ArchivedIndexMap<K, V>

where K: CheckBytes<C> + Eq + Hash, V: CheckBytes<C>, C: ArchiveContext + ?Sized, C::Error: Error,

type Error = IndexMapError<<K as CheckBytes<C>>::Error, <V as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<K, V, C> CheckBytes<C> for Entry<K, V>

where K: CheckBytes<C>, V: CheckBytes<C>, C: ArchiveContext + ?Sized,

type Error = ArchivedEntryError<<K as CheckBytes<C>>::Error, <V as CheckBytes<C>>::Error>

impl<T, C> CheckBytes<C> for ArchivedBox<T>

where T: ArchivePointee + CheckBytes<C> + LayoutRaw + Pointee + ?Sized, C: ArchiveContext + ?Sized, T::ArchivedMetadata: CheckBytes<C>, C::Error: Error,

type Error = OwnedPointerError<<<T as ArchivePointee>::ArchivedMetadata as CheckBytes<C>>::Error, <T as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<T, C> CheckBytes<C> for ArchivedVec<T>

where T: CheckBytes<C>, C: ArchiveContext + ?Sized, C::Error: Error,

type Error = OwnedPointerError<<<[T] as ArchivePointee>::ArchivedMetadata as CheckBytes<C>>::Error, <[T] as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<T, C> CheckBytes<C> for RawArchivedVec<T>

where T: CheckBytes<C>, C: ArchiveContext + ?Sized, C::Error: Error,

type Error = OwnedPointerError<<<[T] as ArchivePointee>::ArchivedMetadata as CheckBytes<C>>::Error, <[T] as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<T, F, C> CheckBytes<C> for ArchivedRcWeak<T, F>

where T: ArchivePointee + CheckBytes<C> + LayoutRaw + Pointee + ?Sized + 'static, C: ArchiveContext + SharedContext + ?Sized, T::ArchivedMetadata: CheckBytes<C>, C::Error: Error, F: 'static,

type Error = WeakPointerError<<<T as ArchivePointee>::ArchivedMetadata as CheckBytes<C>>::Error, <T as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<T, F, C> CheckBytes<C> for ArchivedRc<T, F>

where T: ArchivePointee + CheckBytes<C> + LayoutRaw + Pointee + ?Sized + 'static, C: ArchiveContext + SharedContext + ?Sized, T::ArchivedMetadata: CheckBytes<C>, C::Error: Error, F: 'static,

type Error = SharedPointerError<<<T as ArchivePointee>::ArchivedMetadata as CheckBytes<C>>::Error, <T as CheckBytes<C>>::Error, <C as Fallible>::Error>

impl<T: CheckBytes<C> + ?Sized, C: ?Sized> CheckBytes<C> for Immutable<T>

type Error = <T as CheckBytes<C>>::Error

impl<__C: ?Sized> CheckBytes<__C> for ArchivedIpAddr

where ArchivedIpv4Addr: CheckBytes<__C>, ArchivedIpv6Addr: CheckBytes<__C>,

type Error = EnumCheckError<u8>

impl<__C: ?Sized> CheckBytes<__C> for ArchivedSocketAddr

where ArchivedSocketAddrV4: CheckBytes<__C>, ArchivedSocketAddrV6: CheckBytes<__C>,

type Error = EnumCheckError<u8>

impl<__C: ?Sized> CheckBytes<__C> for ArchivedIpv4Addr

where [Archived<u8>; 4]: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized> CheckBytes<__C> for ArchivedIpv6Addr

where [Archived<u8>; 16]: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized> CheckBytes<__C> for ArchivedSocketAddrV4

where ArchivedIpv4Addr: CheckBytes<__C>, Archived<u16>: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized> CheckBytes<__C> for ArchivedSocketAddrV6

where ArchivedIpv6Addr: CheckBytes<__C>, Archived<u16>: CheckBytes<__C>, Archived<u32>: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized, K> CheckBytes<__C> for ArchivedBTreeSet<K>

where ArchivedBTreeMap<K, ()>: CheckBytes<__C>,

type Error = TupleStructCheckError

impl<__C: ?Sized, K> CheckBytes<__C> for ArchivedHashSet<K>

where ArchivedHashMap<K, ()>: CheckBytes<__C>,

type Error = TupleStructCheckError

impl<__C: ?Sized, K> CheckBytes<__C> for ArchivedIndexSet<K>

where ArchivedIndexMap<K, ()>: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized, T> CheckBytes<__C> for ArchivedOption<T>

where T: CheckBytes<__C>,

type Error = EnumCheckError<u8>

impl<__C: ?Sized, T> CheckBytes<__C> for ArchivedRange<T>

where T: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized, T> CheckBytes<__C> for ArchivedRangeFrom<T>

where T: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized, T> CheckBytes<__C> for ArchivedRangeInclusive<T>

where T: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized, T> CheckBytes<__C> for ArchivedRangeTo<T>

where T: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized, T> CheckBytes<__C> for ArchivedRangeToInclusive<T>

where T: CheckBytes<__C>,

type Error = StructCheckError

impl<__C: ?Sized, T, E> CheckBytes<__C> for ArchivedResult<T, E>

where T: CheckBytes<__C>, E: CheckBytes<__C>,

type Error = EnumCheckError<u8>