Struct SizeError

pub struct SizeError<Src, Dst: ?Sized> { /* private fields */ }

The error emitted if the conversion source is of incorrect size.

Implementations

impl<Src, Dst: ?Sized> SizeError<Src, Dst>

fn into_src(self) -> Src

Produces the source underlying the failed conversion.

fn map_src<NewSrc>(self, f: impl FnOnce(Src) -> NewSrc) -> SizeError<NewSrc, Dst>

Maps the source value associated with the conversion error.

This can help mitigate [issues with Send, Sync and 'static bounds][self#send-sync-and-static].

Examples

use zerocopy::*;

let source: [u8; 3] = [0, 1, 2];

// Try to read a `u32` from `source`. This will fail because there are insufficient
// bytes in `source`.
let maybe_u32: Result<u32, SizeError<&[u8], u32>> = u32::read_from_bytes(&source[..]);

// Map the error's source to its size.
let maybe_u32: Result<u32, SizeError<usize, u32>> = maybe_u32.map_err(|err| {
    err.map_src(|src| src.len())
});

Trait Implementations

impl<Src, Dst> Display for SizeError<Src, Dst> where Src: Deref, Dst: KnownLayout + ?Sized,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<Src, Dst> Error for SizeError<Src, Dst> where Src: Deref, Dst: KnownLayout + ?Sized,

impl<Src, Dst: ?Sized + Unaligned> From<ConvertError<AlignmentError<Src, Dst>, SizeError<Src, Dst>, never>> for SizeError<Src, Dst>

fn from(err: CastError<Src, Dst>) -> SizeError<Src, Dst>

Infallibly extracts the SizeError from this CastError since Dst is unaligned.

Since Dst: Unaligned, it is impossible to encounter an alignment error, and so the only error that can be encountered at runtime is a SizeError. This method permits extracting that SizeError infallibly.

Examples

use zerocopy::*;
# use zerocopy_derive::*;

#[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
#[repr(C)]
struct UdpHeader {
    src_port: [u8; 2],
    dst_port: [u8; 2],
    length: [u8; 2],
    checksum: [u8; 2],
}

#[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
#[repr(C, packed)]
struct UdpPacket {
    header: UdpHeader,
    body: [u8],
}

impl UdpPacket {
    pub fn parse(bytes: &[u8]) -> Result<&UdpPacket, SizeError<&[u8], UdpPacket>> {
        // Since `UdpPacket: Unaligned`, we can map the `CastError` to a `SizeError`.
        UdpPacket::ref_from_bytes(bytes).map_err(Into::into)
    }
}

impl<Src, Dst: ?Sized> Debug for SizeError<Src, Dst>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<Src: Clone, Dst: ?Sized> Clone for SizeError<Src, Dst>

fn clone(&self) -> Self

impl<Src: Eq, Dst: ?Sized> Eq for SizeError<Src, Dst>

impl<Src: PartialEq, Dst: ?Sized> PartialEq for SizeError<Src, Dst>

fn eq(&self, other: &Self) -> bool

Auto Trait Implementations

impl<Src, Dst> Freeze for SizeError<Src, Dst> where Src: Freeze, SendSyncPhantomData<Dst>: Freeze, Dst: ?Sized,

impl<Src, Dst> RefUnwindSafe for SizeError<Src, Dst> where Src: RefUnwindSafe, SendSyncPhantomData<Dst>: RefUnwindSafe, Dst: ?Sized,

impl<Src, Dst> Send for SizeError<Src, Dst> where Src: Send, SendSyncPhantomData<Dst>: Send, Dst: ?Sized,

impl<Src, Dst> Sync for SizeError<Src, Dst> where Src: Sync, SendSyncPhantomData<Dst>: Sync, Dst: ?Sized,

impl<Src, Dst> Unpin for SizeError<Src, Dst> where Src: Unpin, SendSyncPhantomData<Dst>: Unpin, Dst: ?Sized,

impl<Src, Dst> UnsafeUnpin for SizeError<Src, Dst> where Src: UnsafeUnpin, SendSyncPhantomData<Dst>: UnsafeUnpin, Dst: ?Sized,

impl<Src, Dst> UnwindSafe for SizeError<Src, Dst> where Src: UnwindSafe, SendSyncPhantomData<Dst>: UnwindSafe, Dst: ?Sized,

Blanket Implementations

impl<T> Any for SizeError<Src, Dst> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for SizeError<Src, Dst> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for SizeError<Src, Dst> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for SizeError<Src, Dst> where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for SizeError<Src, Dst>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for SizeError<Src, Dst> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for SizeError<Src, Dst> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for SizeError<Src, Dst> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>