Struct SizeCache 

pub struct SizeCache<T = ()> {
    pub value: usize,
    pub constrained: bool,
    pub extra: T,
}

Cache around a one-dimensional layout result.

This is not a View, but something to help you if you create your own Views.

Fields

value: usize

Cached value

constrained: bool

true if the last size was constrained.

If unconstrained, any request larger than this value would return the same size.

extra: T

Extra field.

Implementations

impl SizeCache

pub fn new(value: usize, constrained: bool) -> SizeCache

Creates a new sized cache

pub fn build(size: XY<usize>, req: XY<usize>) -> XY<SizeCache>

Creates a new bi-dimensional cache.

It will stay valid for the same request, and compatible ones.

A compatible request is one where, for each axis, either:

• the request is equal to the cached size, or
• the request is larger than the cached size and the cache is unconstrained

Notes:

• size must fit inside req.
• for each dimension, constrained = (size == req)

impl<T> SizeCache<T>

pub fn new_extra(value: usize, constrained: bool, extra: T) -> SizeCache<T>

Creates a new sized cache

pub fn build_extra( size: XY<usize>, req: XY<usize>, extra: XY<T>, ) -> XY<SizeCache<T>>

Creates a new bi-dimensional cache.

Similar to build(), but includes the extra field.

pub fn accept(self, request: usize) -> bool

Returns true if self is still valid for the given request.

pub fn value(self) -> usize

Returns the value in the cache.

Trait Implementations

impl<T> Clone for SizeCache<T>

where T: Clone,

fn clone(&self) -> SizeCache<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for SizeCache<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> PartialEq for SizeCache<T>

where T: PartialEq,

fn eq(&self, other: &SizeCache<T>) -> 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<T> Copy for SizeCache<T>

where T: Copy,

impl<T> Eq for SizeCache<T>

where T: Eq,

impl<T> StructuralPartialEq for SizeCache<T>