Struct Limits

pub struct Limits {
    pub max_image_width: Option<u32>,
    pub max_image_height: Option<u32>,
    pub max_alloc: Option<u64>,
    /* private fields */
}

Resource limits for decoding.

Limits can be either strict or non-strict. Non-strict limits are best-effort limits where the library does not guarantee that limit will not be exceeded. Do note that it is still considered a bug if a non-strict limit is exceeded, however as some of the underlying decoders do not support not support such limits one cannot rely on these limits being supported. For stric limits the library makes a stronger guarantee that the limit will not be exceeded. Exceeding a strict limit is considered a critical bug. If a decoder cannot guarantee that it will uphold a strict limit it must fail with image::error::LimitErrorKind::Unsupported.

Currently the only strict limits supported are the max_image_width and max_image_height limits, however more will be added in the future. LimitSupport will default to support being false and decoders should enable support for the limits they support in ImageDecoder::set_limits.

The limit check should only ever fail if a limit will be exceeded or an unsupported strict limit is used.

Fields

max_image_width: Option<u32>

The maximum allowed image width. This limit is strict. The default is no limit.

max_image_height: Option<u32>

The maximum allowed image height. This limit is strict. The default is no limit.

max_alloc: Option<u64>

The maximum allowed sum of allocations allocated by the decoder at any one time excluding allocator overhead. This limit is non-strict by default and some decoders may ignore it. The default is 512MiB.

Implementations

impl Limits

pub fn no_limits() -> Limits

Disable all limits.

pub fn check_support(&self, _supported: &LimitSupport) -> ImageResult<()>

This function checks that all currently set strict limits are supported.

pub fn check_dimensions(&self, width: u32, height: u32) -> ImageResult<()>

This function checks the max_image_width and max_image_height limits given the image width and height.

pub fn reserve(&mut self, amount: u64) -> ImageResult<()>

This function checks that the current limit allows for reserving the set amount of bytes, it then reduces the limit accordingly.

pub fn reserve_usize(&mut self, amount: usize) -> ImageResult<()>

This function acts identically to [reserve], but takes a usize for convenience.

pub fn reserve_buffer( &mut self, width: u32, height: u32, color_type: ColorType, ) -> ImageResult<()>

This function acts identically to [reserve], but accepts the width, height and color type used to create an [ImageBuffer] and does all the math for you.

pub fn free(&mut self, amount: u64)

This function increases the max_alloc limit with amount. Should only be used together with reserve.

pub fn free_usize(&mut self, amount: usize)

This function acts identically to [free], but takes a usize for convenience.

Trait Implementations

impl Clone for Limits

fn clone(&self) -> Limits

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Limits

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

Formats the value using the given formatter.

impl Default for Limits

fn default() -> Limits

Returns the “default value” for a type.

impl Hash for Limits

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 PartialEq for Limits

fn eq(&self, other: &Limits) -> 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 Eq for Limits

impl StructuralPartialEq for Limits