Struct Registry 

pub struct Registry<'src> {
    table: EytzingerMap<u32, NodeRef<'src>>,
}

Whole-document registry — single Eytzinger-keyed table.

node_at is one binary search, and every entry’s sentinel kind is encoded by the NodeRef variant — renderers pattern-match the hit inline rather than dispatching across per-kind tables.

Fields

table: EytzingerMap<u32, NodeRef<'src>>

Single SoA lookup table keyed by normalized byte position. Built once at pipeline-build time from the classifier’s emit stream; entries arrive in strictly increasing position order because the classifier tiles spans contiguously.

Implementations

impl<'src> Registry<'src>

pub fn from_sorted_slice(entries: &[(u32, NodeRef<'src>)]) -> Self

Construct a registry from a position-sorted slice of (position, NodeRef) entries.

Panics

Inherits [EytzingerMap::from_sorted_slice]’s precondition: the slice must be sorted by key. The lex pipeline always emits in source order, so this is satisfied by construction.

pub const fn empty() -> Self

Empty registry. Useful as a starting point for incremental construction (the lex driver pushes into a builder vec that later collapses into the Eytzinger table).

pub fn is_empty(&self) -> bool

True iff the registry holds no entries.

pub fn len(&self) -> usize

Total number of entries across all sentinel kinds. O(1).

pub fn node_at(&self, pos: NormalizedOffset) -> Option<NodeRef<'src>>

Look up the registry entry at the given normalized-text byte position. Returns None if no sentinel landed at that position.

The argument is a [NormalizedOffset] newtype rather than a raw u32 — editor surfaces that hold a source-coordinate byte offset must first translate via BorrowedLexOutput::node_at_source (which walks a source-keyed side-table built during the lex pipeline) instead of casting between the two coordinate spaces.

pub fn iter_sorted(&self) -> impl Iterator<Item = (u32, NodeRef<'src>)> + '_

Iterate over (position, NodeRef) entries in ascending position order. Useful for tests and tooling that want to enumerate everything the registry holds.

pub fn iter_kind( &self, kind: Sentinel, ) -> impl Iterator<Item = (u32, NodeRef<'src>)> + '_

Iterate over entries whose NodeRef::sentinel_kind matches kind. O(n) but the filter is a constant-time variant discriminant compare.

pub fn count_kind(&self, kind: Sentinel) -> usize

Count entries whose NodeRef::sentinel_kind matches kind.

O(n) over the table. Cardinality assertions in unit tests drive this; production lookups go through Self::node_at.

Trait Implementations

impl<'src> Clone for Registry<'src>

fn clone(&self) -> Registry<'src>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'src> Debug for Registry<'src>

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

Formats the value using the given formatter.

impl Default for Registry<'_>

fn default() -> Self

Returns the “default value” for a type.