Enum Node 

pub enum Node<Loc = Span> {
    Scalar {
        value: String,
        style: ScalarStyle,
        tag: Option<Cow<'static, str>>,
        loc: Loc,
        meta: Option<Box<NodeMeta<Loc>>>,
    },
    Mapping {
        entries: Vec<(Self, Self)>,
        style: CollectionStyle,
        tag: Option<Cow<'static, str>>,
        loc: Loc,
        meta: Option<Box<NodeMeta<Loc>>>,
    },
    Sequence {
        items: Vec<Self>,
        style: CollectionStyle,
        tag: Option<Cow<'static, str>>,
        loc: Loc,
        meta: Option<Box<NodeMeta<Loc>>>,
    },
    Alias {
        name: String,
        loc: Loc,
        leading_comments: Option<Vec<String>>,
        trailing_comment: Option<String>,
    },
}

A YAML node parameterized by its location type.

Variants

Scalar

A scalar value.

Fields

value: String

The scalar content as a UTF-8 string (after block/flow unfolding).

style: ScalarStyle

The presentation style used in the source (plain, single-quoted, etc.).

tag: Option<Cow<'static, str>>

Tag applied to this node (e.g. !!str), if any.

loc: Loc

Source span covering this scalar in the input.

meta: Option<Box<NodeMeta<Loc>>>

Rare fields: anchor, anchor_loc, tag_loc, leading_comments, trailing_comment. None for the common case where none of these are set.

Mapping

A mapping (sequence of key–value pairs preserving declaration order).

Fields

entries: Vec<(Self, Self)>

Key–value pairs in declaration order.

style: CollectionStyle

The presentation style used in the source (block or flow).

tag: Option<Cow<'static, str>>

Tag applied to this mapping (e.g. !!map), if any.

loc: Loc

Source span from the opening indicator to the last entry.

meta: Option<Box<NodeMeta<Loc>>>

Rare fields: anchor, anchor_loc, tag_loc, leading_comments, trailing_comment. None for the common case where none of these are set.

Sequence

A sequence (ordered list of nodes).

Fields

items: Vec<Self>

Ordered list of child nodes.

style: CollectionStyle

The presentation style used in the source (block or flow).

tag: Option<Cow<'static, str>>

Tag applied to this sequence (e.g. !!seq), if any.

loc: Loc

Source span from the opening indicator to the last item.

meta: Option<Box<NodeMeta<Loc>>>

Rare fields: anchor, anchor_loc, tag_loc, leading_comments, trailing_comment. None for the common case where none of these are set.

Alias

An alias reference (lossless mode only — resolved mode expands these).

Fields

name: String

The anchor name this alias refers to (without the * sigil).

loc: Loc

Source span covering the *name alias token.

leading_comments: Option<Vec<String>>

Comment lines that appear before this node.

trailing_comment: Option<String>

Inline comment on the same line as this node.

Implementations

impl<Loc> Node<Loc>

pub fn anchor(&self) -> Option<&str>

Returns the anchor name if this node defines one.

pub fn anchor_loc(&self) -> Option<Loc>

where Loc: Copy,

Returns the source span of the &name anchor token, if any.

Some(span) when anchor() is Some; None otherwise. Always None for Node::Alias — the alias span is in loc.

pub fn tag_loc(&self) -> Option<Loc>

where Loc: Copy,

Returns the source span of the tag token, if any.

Some(span) when a user-authored tag is present; None for resolver-injected tags. Always None for Node::Alias.

pub fn leading_comments(&self) -> &[String]

Returns the leading comments for this node.

pub fn trailing_comment(&self) -> Option<&str>

Returns the trailing comment for this node, if any.

pub fn clear_anchor(&mut self)

Clear the anchor and anchor_loc on this node (used by code actions that remove unused anchors). No-op on Node::Alias.

Trait Implementations

impl<Loc: Clone> Clone for Node<Loc>

fn clone(&self) -> Node<Loc>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Loc: Debug> Debug for Node<Loc>

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

Formats the value using the given formatter.

impl<Loc: PartialEq> PartialEq for Node<Loc>

fn eq(&self, other: &Node<Loc>) -> 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<Loc> StructuralPartialEq for Node<Loc>