Struct InlineBudget 

pub struct InlineBudget {
    pub rows: usize,
    pub depth: usize,
    pub page_rows: usize,
}

How much of a container’s subtree may be inlined into its parent’s page rather than drilled into — the knob that slides the page projection between its two ancestors.

At the default, a page is a settings menu: small all-scalar groups inline, everything substantial earns a page. Raised far enough, the root page simply is the whole document — the settings-list rendering, absorbed — and a small document never asks for a navigation step at all. The embedder picks, because the right answer is about the room the pages are drawn in, not about the document.

Fields

rows: usize

The most rows an inlined subtree may contribute to the page. Every descendant is a row — nested containers add their headers too — so this is the honest cost of saying yes.

depth: usize

The most ranks of nesting an inlined subtree may reach: 1 admits only all-scalar groups, 2 lets those groups hold one more rank of groups, and so on. Rendered as PageItem::inset, so this bounds the indentation a page can ask a frontend to draw.

page_rows: usize

The most rows one page will spend on the items of a sequence it inlines ([seq_inlines]) — the limit rows cannot express, because that one is asked once per item and this one once per page.

Twenty-two entries of three scalars each pass a per-item budget individually and put eighty rows on one page between them. Every individual yes was right and the page is still wrong, so the page gets a say of its own.

Implementations

impl InlineBudget

pub fn new(rows: usize, depth: usize) -> Self

A budget from the two per-subtree limits, with a page limit at least as generous as PAGE_INLINE_MAX.

Raising rows past it raises the page’s limit with it: a caller asking for a hundred rows of subtree is asking for a page that can hold them, and a page cap left at the default would refuse what the caller just paid for.

pub fn fitting(root: &Value, room: usize) -> Self

The budget that shows as much of root as room rows allow.

The founding rule is a constant, and a constant cannot be right about a room it has never seen: six rows and one rank is a wise default over a deep CI config in a narrow pane, and a needless navigation step over a document that would have fit on screen whole. This asks the document and the room instead.

Two answers. If the whole document fits — few enough rows, and shallow enough (FIT_MAX_DEPTH) that the insets stay readable — the budget is the document’s own size and the root page simply is the document: no navigation at all for a file that never needed any, which is the general form of “a file that is only one array belongs on one page”. Otherwise it is the founding rule with the page limit set to the room, so a taller terminal inlines a longer list and a short one does not.

Measured over the whole document, hidden keys included: they are the embedder’s few reserved names, and counting them costs at most a row of slack in a heuristic that is choosing between two roundings anyway.

Trait Implementations

impl Clone for InlineBudget

fn clone(&self) -> InlineBudget

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for InlineBudget

impl Debug for InlineBudget

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

Formats the value using the given formatter.

impl Default for InlineBudget

fn default() -> Self

The founding rule: at most INLINE_MAX members, all of them scalars, and at most PAGE_INLINE_MAX rows of them on any one page.

impl Eq for InlineBudget

impl PartialEq for InlineBudget

fn eq(&self, other: &InlineBudget) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for InlineBudget