Enum NodeRef 

#[non_exhaustive]
pub enum NodeRef<'src> {
    Inline(AozoraNode<'src>),
    BlockLeaf(AozoraNode<'src>),
    BlockOpen(ContainerKind),
    BlockClose(ContainerKind),
}

Unified view over a registry hit, returned by Registry::node_at.

Each variant tags the sentinel kind that fired; renderers pattern-match the variant once, then handle the inline payload (a borrowed AozoraNode) or the container payload (a ContainerKind enum) accordingly.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Inline(AozoraNode<'src>)

Hit on an inline-sentinel position (aozora_spec::Sentinel::Inline).

BlockLeaf(AozoraNode<'src>)

Hit on a block-leaf-sentinel position (aozora_spec::Sentinel::BlockLeaf).

BlockOpen(ContainerKind)

Hit on a block-container-open position (aozora_spec::Sentinel::BlockOpen).

BlockClose(ContainerKind)

Hit on a block-container-close position (aozora_spec::Sentinel::BlockClose).

Implementations

impl NodeRef<'_>

pub const fn sentinel_kind(self) -> Sentinel

Sentinel kind that produced this entry.

Useful for tests / tooling that want to bucket registry entries by sentinel kind without depending on the variant payload shape.

pub const fn kind(self) -> NodeKind

Cross-cutting crate::NodeKind tag for this entry.

Inline / block-leaf hits project to the underlying AozoraNode::kind tag; container open / close hits flatten into NodeKind::ContainerOpen / ContainerClose because the wire format places container kind detail in the inline span rather than on the open/close marker.

Trait Implementations

impl<'src> Clone for NodeRef<'src>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'src> Copy for NodeRef<'src>

impl<'src> Debug for NodeRef<'src>

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

Formats the value using the given formatter.

impl<'src> PartialEq for NodeRef<'src>

fn eq(&self, other: &NodeRef<'src>) -> 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<'src> StructuralPartialEq for NodeRef<'src>