Struct cursive_core::view::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) -> Self

Creates a new sized cache

pub fn build(size: Vec2, req: Vec2) -> XY<Self>

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) -> Self

Creates a new sized cache

pub fn build_extra(size: Vec2, req: Vec2, extra: XY<T>) -> XY<Self>

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> Clone for SizeCache<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SizeCache<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq<SizeCache<T>> for SizeCache<T>

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

impl<T: Eq> Eq for SizeCache<T>

impl<T> StructuralEq for SizeCache<T>

impl<T> StructuralPartialEq for SizeCache<T>