Struct CachedInlineLayout 

pub struct CachedInlineLayout {
    pub layout: Arc<UnifiedLayout>,
    pub available_width: AvailableSpace,
    pub has_floats: bool,
    pub constraints: Option<UnifiedConstraints>,
}

Cached inline layout result with the constraints used to compute it.

This structure solves a fundamental architectural problem: inline layouts (text wrapping, inline-block positioning) depend on the available width. Different layout phases may compute the layout with different widths:

1. Min-content measurement: width = MinContent (effectively 0)
2. Max-content measurement: width = MaxContent (effectively infinite)
3. Final layout: width = Definite(actual_column_width)

Without tracking which constraints were used, a cached result from phase 1 would incorrectly be reused in phase 3, causing text to wrap at the wrong positions (the root cause of table cell width bugs).

By storing the constraints alongside the result, we can:

• Invalidate the cache when constraints change
• Keep multiple cached results for different constraint types if needed
• Ensure the final render always uses a layout computed with correct widths

Fields

layout: Arc<UnifiedLayout>

The computed inline layout

available_width: AvailableSpace

The available width constraint used to compute this layout. This is the key for cache validity checking.

has_floats: bool

Whether this layout was computed with float exclusions. Float-aware layouts should not be overwritten by non-float layouts.

constraints: Option<UnifiedConstraints>

The full constraints used to compute this layout. Used for quick relayout after text edits without rebuilding from CSS.

Implementations

impl CachedInlineLayout

pub fn new( layout: Arc<UnifiedLayout>, available_width: AvailableSpace, has_floats: bool, ) -> Self

Creates a new cached inline layout.

pub fn new_with_constraints( layout: Arc<UnifiedLayout>, available_width: AvailableSpace, has_floats: bool, constraints: UnifiedConstraints, ) -> Self

Creates a new cached inline layout with full constraints.

pub fn is_valid_for( &self, new_width: AvailableSpace, new_has_floats: bool, ) -> bool

Checks if this cached layout is valid for the given constraints.

A cached layout is valid if:

1. The available width matches (definite widths must be equal, or both are the same indefinite type)
2. OR the new request doesn’t have floats but the cached one does (keep float-aware layout)

The second condition preserves float-aware layouts, which are more “correct” than non-float layouts and shouldn’t be overwritten.

pub fn should_replace_with( &self, new_width: AvailableSpace, new_has_floats: bool, ) -> bool

Determines if this cached layout should be replaced by a new layout.

Returns true if the new layout should replace this one.

pub fn get_layout(&self) -> &Arc<UnifiedLayout>

Returns a reference to the inner UnifiedLayout.

This is a convenience method for code that only needs the layout data and doesn’t care about the caching metadata.

pub fn clone_layout(&self) -> Arc<UnifiedLayout>

Returns a clone of the inner Arc.

This is useful for APIs that need to return an owned reference to the layout without exposing the caching metadata.

Trait Implementations

impl Clone for CachedInlineLayout

fn clone(&self) -> CachedInlineLayout

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CachedInlineLayout

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

Formats the value using the given formatter.