Struct Index 

pub struct Index {
    parent: HashMap<BlockId, Scope>,
    matched: HashSet<BlockId>,
}

The child→parent links of the whole reachable tree and, while searching, the blocks whose own label matches.

Ancestors are not in the matched set: a match’s ancestry renders as a path under its label, never as rows of its own. The top block is never included either — it is the invisible root the tree hangs from.

Fields

parent: HashMap<BlockId, Scope>

matched: HashSet<BlockId>

Implementations

impl Index

pub fn of(tree: &NavTree, filter: Option<&str>) -> Self

Index tree, marking what filter matches.

The walk starts at the document’s root whatever the tree is focused on, which is what makes the filter cross the focus boundary.

pub fn parent_of(&self, id: BlockId) -> Option<Scope>

Where id hangs — the scope holding it, which is the tree’s root for a block the root itself holds.

pub fn ancestor_ids(&self, top: Scope, target: BlockId) -> Vec<BlockId>

Every ancestor of target between top and it, outermost first.

pub fn under(&self, root: BlockId, target: BlockId) -> bool

Whether target is inside root’s subtree — what tells a reveal whether the current focus would hide the row it is about to select.

pub fn expand_ancestors( &self, top: Scope, target: BlockId, expanded: &mut HashSet<BlockId>, )

Open every ancestor of target up to, but not including, top, so target’s row appears in the flattened tree. target itself is left as it was — revealing a block does not expand its own children.

pub fn ancestry(&self, tree: &NavTree, id: BlockId) -> Vec<String>

The labels between the tree’s root and id, root first — what is printed under a match. Empty for a child of the root, which has no ancestry to explain.

pub fn rows( &self, tree: &NavTree, expanded: &HashSet<BlockId>, root: Scope, filtered: Filtered, ) -> Vec<Row>

Depth-first flatten of the tree hanging from root.

Filtered::Yes descends everywhere but emits only the matches, flat and carrying their ancestry; Filtered::No emits the tree as it stands, opened where the user opened it.

fn walk(&self, at: Walk<'_>, out: &mut Vec<Row>)