Enum Reason

pub enum Reason<T> {
    SrcIsNotYetSupported,
    DstIsNotYetSupported,
    DstIsBitIncompatible,
    DstUninhabited,
    DstMayHaveSafetyInvariants,
    DstIsTooBig,
    DstRefIsTooBig {
        src: T,
        dst: T,
    },
    DstHasStricterAlignment {
        src_min_align: usize,
        dst_min_align: usize,
    },
    DstIsMoreUnique,
    TypeError,
    SrcLayoutUnknown,
    DstLayoutUnknown,
    SrcSizeOverflow,
    DstSizeOverflow,
}

Answers “why wasn’t the source type transmutable into the destination type?”

Variants

SrcIsNotYetSupported

The layout of the source type is not yet supported.

DstIsNotYetSupported

The layout of the destination type is not yet supported.

DstIsBitIncompatible

The layout of the destination type is bit-incompatible with the source type.

DstUninhabited

The destination type is uninhabited.

DstMayHaveSafetyInvariants

The destination type may carry safety invariants.

DstIsTooBig

Dst is larger than Src, and the excess bytes were not exclusively uninitialized.

DstRefIsTooBig

A referent of Dst is larger than a referent in Src.

Fields

src: T

The referent of the source type.

dst: T

The too-large referent of the destination type.

DstHasStricterAlignment

Src should have a stricter alignment than Dst, but it does not.

Fields

src_min_align: usize

dst_min_align: usize

DstIsMoreUnique

Can’t go from shared pointer to unique pointer

TypeError

Encountered a type error

SrcLayoutUnknown

The layout of src is unknown

DstLayoutUnknown

The layout of dst is unknown

SrcSizeOverflow

The size of src is overflow

DstSizeOverflow

The size of dst is overflow

Trait Implementations

impl<T: Clone> Clone for Reason<T>

fn clone(&self) -> Reason<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Reason<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Reason<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord> Ord for Reason<T>

fn cmp(&self, other: &Reason<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Reason<T>

fn eq(&self, other: &Reason<T>) -> 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<T: PartialOrd> PartialOrd for Reason<T>

fn partial_cmp(&self, other: &Reason<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq> Eq for Reason<T>

impl<T> StructuralPartialEq for Reason<T>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.