Struct rerun::external::image::Limits

#[non_exhaustive]
pub struct Limits {
    pub max_image_width: Option<u32>,
    pub max_image_height: Option<u32>,
    pub max_alloc: Option<u64>,
}

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. Some of the underlying decoders do not support such limits, so one cannot rely on these limits being supported. For strict 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 error::LimitErrorKind::Unsupported.

The only currently supported strict limits are the max_image_width and max_image_height limits, but 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 (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

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 bytes required to store the output image count towards this value. The default is 512MiB.

Implementations

impl Limits

pub fn no_limits() -> Limits

Disable all limits.

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

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

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

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) -> Result<(), ImageError>

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) -> Result<(), ImageError>

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 ) -> Result<(), ImageError>

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<(), Error>

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>(&self, state: &mut __H)

where __H: Hasher,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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