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

fn into_src(self: Self) -> Src

Produces the source underlying the failed conversion.

fn map_src<NewSrc, impl FnOnce(Src) -> NewSrc: FnOnce(Src) -> NewSrc>(self: 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())
});

impl<Src, Dst> Display for SizeError<Src, Dst>

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

impl<Src, Dst> Error for SizeError<Src, Dst>

impl<Src, Dst> Freeze for SizeError<Src, Dst>

impl<Src, Dst> RefUnwindSafe for SizeError<Src, Dst>

impl<Src, Dst> Send for SizeError<Src, Dst>

impl<Src, Dst> Sync for SizeError<Src, Dst>

impl<Src, Dst> Unpin for SizeError<Src, Dst>

impl<Src, Dst> UnsafeUnpin for SizeError<Src, Dst>

impl<Src, Dst> UnwindSafe for SizeError<Src, Dst>

impl<Src, Dst: ?Sized + Unaligned> From 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: &Self, f: &mut Formatter<'_>) -> Result

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

fn clone(self: &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: &Self, other: &Self) -> bool

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

fn type_id(self: &Self) -> TypeId

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

fn borrow(self: &Self) -> &T

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

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

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

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

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

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for SizeError<Src, Dst>

fn into(self: 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 for SizeError<Src, Dst>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for SizeError<Src, Dst>

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