Enum `LimitErrorKind`

#[non_exhaustive]
pub 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: Limits, supported: LimitSupport }: The specified strict limits are not supported for this operation

Trait Implementations

`impl Clone for LimitErrorKind`

fn clone(&self) -> LimitErrorKind

`impl Debug for LimitErrorKind`

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

`impl Eq for LimitErrorKind`

`impl Hash for LimitErrorKind`

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

`impl PartialEq for LimitErrorKind`

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

`impl StructuralPartialEq for LimitErrorKind`

Auto Trait Implementations

`impl Freeze for LimitErrorKind`

`impl RefUnwindSafe for LimitErrorKind`

`impl Send for LimitErrorKind`

`impl Sync for LimitErrorKind`

`impl Unpin for LimitErrorKind`

`impl UnsafeUnpin for LimitErrorKind`

`impl UnwindSafe for LimitErrorKind`

Blanket Implementations

`impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for LimitErrorKind where ST: ?Sized, DT: ?Sized,`

`impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for LimitErrorKind where ST: ?Sized, DT: ?Sized,`

`impl<T> Any for LimitErrorKind where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for LimitErrorKind where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for LimitErrorKind where T: ?Sized,`

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

`impl<T> CloneToUninit for LimitErrorKind where T: Clone,`

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

`impl<T> From<T> for LimitErrorKind`

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

`impl<T> IntoEither for LimitErrorKind`

`impl<T> Pointable for LimitErrorKind`

const ALIGN: usize = _;
type Init = T;
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> Read<Exclusive, BecauseExclusive> for LimitErrorKind where T: ?Sized,`

`impl<T> ToOwned for LimitErrorKind where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into<U> for LimitErrorKind 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 LimitErrorKind where U: Into<T>,`

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

`impl<T, U> TryInto<U> for LimitErrorKind where U: TryFrom<T>,`

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