Struct SizeError

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

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

Implementations

impl<Src, Dst> SizeError<Src, Dst>

where Dst: ?Sized,

pub fn into_src(self) -> Src

Produces the source underlying the failed conversion.

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

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> Debug for SizeError<Src, Dst>

where Dst: ?Sized,

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

Formats the value using the given formatter.

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

where Src: Deref, Dst: KnownLayout + ?Sized,

Produces a human-readable error message.

The message differs between debug and release builds. When debug_assertions are enabled, this message is verbose and includes potentially sensitive information.

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

Formats the value using the given formatter.

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

where Src: Deref, Dst: KnownLayout + ?Sized,

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<Src, Dst> From<ConvertError<AlignmentError<Src, Dst>, SizeError<Src, Dst>, Infallible>> for SizeError<Src, Dst>

where Dst: Unaligned + ?Sized,

fn from( err: ConvertError<AlignmentError<Src, Dst>, SizeError<Src, Dst>, Infallible>, ) -> 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::*;

#[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<A, B> From<SizeError<A, B>> for Error

fn from(_: SizeError<A, B>) -> Error

Converts to this type from the input type.

impl<A, B> From<SizeError<A, B>> for Error

fn from(_: SizeError<A, B>) -> Error

Converts to this type from the input type.

impl<A, B> From<SizeError<A, B>> for Error

fn from(_: SizeError<A, B>) -> Error

Converts to this type from the input type.

impl<Src, Dst, A, V> From<SizeError<Src, Dst>> for ConvertError<A, SizeError<Src, Dst>, V>

where Dst: ?Sized,

fn from(err: SizeError<Src, Dst>) -> ConvertError<A, SizeError<Src, Dst>, V>

Converts to this type from the input type.

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

where Src: PartialEq, Dst: PartialEq + ?Sized,

fn eq(&self, other: &SizeError<Src, Dst>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

where Src: Eq, Dst: Eq + ?Sized,

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

where Dst: ?Sized,