Struct `Limits`

#[non_exhaustive]
pub struct Limits { pub decoding_buffer_size: usize, pub ifd_value_size: usize, pub intermediate_buffer_size: usize }

Decoding limits

Fields

decoding_buffer_size: usize: The maximum size of any DecodingResult in bytes, the default is 256MiB. If the entire image is decoded at once, then this will be the maximum size of the image. If it is decoded one strip at a time, this will be the maximum size of a strip.
ifd_value_size: usize: The maximum size of any ifd value in bytes, the default is 1MiB.
intermediate_buffer_size: usize: Maximum size for intermediate buffer which may be used to limit the amount of data read per segment even if the entire image is decoded at once.

Implementations

`impl Limits`

fn unlimited() -> Limits

A configuration that does not impose any limits.

This is a good start if the caller only wants to impose selective limits, contrary to the default limits which allows selectively disabling limits.

Note that this configuration is likely to crash on excessively large images since, naturally, the machine running the program does not have infinite memory.

Trait Implementations

`impl Clone for Limits`

fn clone(&self) -> Self

`impl Debug for Limits`

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

`impl Default for Limits`

fn default() -> Limits

Auto Trait Implementations

`impl Freeze for Limits`

`impl RefUnwindSafe for Limits`

`impl Send for Limits`

`impl Sync for Limits`

`impl Unpin for Limits`

`impl UnsafeUnpin for Limits`

`impl UnwindSafe for Limits`

Blanket Implementations

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

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

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

`impl<T> From<T> for Limits`

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

`impl<T> Read<Exclusive, BecauseExclusive> for Limits where T: ?Sized,`

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

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

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

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

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

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