Enum `LimitErrorKind`

enum LimitErrorKind

Indicates the limit that prevented an operation from completing.

Note that this enumeration is not exhaustive and may in the future be extended to provide more detailed information or to incorporate other resources types.

Variants

DimensionError: The resulting image exceed dimension limits in either direction.
InsufficientMemory: The operation would have performed an allocation larger than allowed.
Unsupported { limits: crate::Limits, supported: crate::LimitSupport }: The specified strict limits are not supported for this operation

Implementations

`impl Clone for LimitErrorKind`

fn clone(self: &Self) -> LimitErrorKind

`impl Debug for LimitErrorKind`

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

`impl Eq for LimitErrorKind`

`impl Freeze for LimitErrorKind`

`impl Hash for LimitErrorKind`

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

`impl PartialEq for LimitErrorKind`

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

`impl RefUnwindSafe for LimitErrorKind`

`impl Send for LimitErrorKind`

`impl StructuralPartialEq for LimitErrorKind`

`impl Sync for LimitErrorKind`

`impl Unpin for LimitErrorKind`

`impl UnwindSafe for LimitErrorKind`

`impl<T> Any for LimitErrorKind`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for LimitErrorKind`

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

`impl<T> BorrowMut for LimitErrorKind`

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

`impl<T> CloneToUninit for LimitErrorKind`

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

`impl<T> From for LimitErrorKind`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Pointable for LimitErrorKind`

unsafe fn init(init: <T as Pointable>::Init) -> usize
unsafe fn deref<'a>(ptr: usize) -> &'a T
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
unsafe fn drop(ptr: usize)

`impl<T> ToOwned for LimitErrorKind`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for LimitErrorKind`

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 LimitErrorKind`

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

`impl<T, U> TryInto for LimitErrorKind`

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