Enum Length 

pub enum Length {
    Auto,
    Cells(u16),
    Percent(u16),
    Min(u16),
    Max(u16),
    Var {
        name: String,
        fallback: Option<Box<Length>>,
    },
}

A one-dimensional size, mapped to a ratatui Constraint.

Not Copy: the Length::Var variant carries a heap-allocated name, so a Length must be .clone()-d when duplicated (which is rare outside the cascade, where var() references have already been resolved away).

Variants

Auto

auto — let the layout engine decide (becomes Min(0)).

Cells(u16)

A fixed cell count (10, 10px).

Percent(u16)

A percentage of the available space (50%).

Min(u16)

min(n) — at least n cells, grow if room.

Max(u16)

max(n) — at most n cells.

Var

A var(--name) reference, resolved against the token table during the cascade. A Length::Var should never survive into to_constraint — if one does (e.g. an unresolved variable in lenient mode), it degrades to Min(0) (same as Length::Auto) rather than panicking.

Fallback (var(--x, 10)) is not yet supported: if a fallback is present it is currently ignored and only the name is captured.

Fields

name: String

fallback: Option<Box<Length>>

Implementations

impl Length

pub fn parse(s: &str) -> Result<Self>

pub fn to_constraint(&self) -> Constraint

Trait Implementations

impl Clone for Length

fn clone(&self) -> Length

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Length

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Length

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl From<Length> for Token

fn from(l: Length) -> Self

Converts to this type from the input type.

impl PartialEq for Length

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

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Length