Enum NodeKind 

#[repr(u8)]
pub enum NodeKind {
    String = 0,
    Number = 1,
    Boolean = 2,
    Null = 3,
    Scalar = 4,
    Object = 16,
    Array = 17,
    Key = 18,
    Value = 19,
    Comment = 32,
    Reference = 33,
    Definition = 34,
    Header = 35,
    Row = 36,
    Section = 37,
    FormatSpecific(FormatSpecificKind),
}

Universal node kinds for filtering (cross-format)

These kinds form a semantic hierarchy that works across all formats, enabling queries like $..::string or $..::reference.

Variants

String = 0

String value

Number = 1

Numeric value (integer or float)

Boolean = 2

Boolean value (true/false)

Null = 3

Null value

Scalar = 4

Any scalar (string, number, boolean, null)

Object = 16

Object/mapping container

Array = 17

Array/sequence container

Key = 18

Key name (in object)

Value = 19

Value (in key-value pair)

Comment = 32

Comment (any format)

Reference = 33

Reference (YAML alias, ISON ref)

Definition = 34

Definition (YAML anchor, ISON table)

Header = 35

Header row/declaration

Row = 36

Data row

Section = 37

Section/block boundary

FormatSpecific(FormatSpecificKind)

Format-specific node kind

Implementations

impl NodeKind

pub const fn is_value_type(self) -> bool

Check if this kind is a value type

pub const fn is_container(self) -> bool

Check if this kind is a container type

pub const fn is_semantic_category(self) -> bool

Check if this kind is a semantic category

pub const fn is_format_specific(self) -> bool

Check if this kind is format-specific

pub fn matches(self, other: Self) -> bool

Check if a kind matches this kind (with inheritance)

Semantic categories match their specific variants:

• Reference matches YamlAlias, IsonRef
• Definition matches YamlAnchor, IsonTable
• etc.

Trait Implementations

impl Clone for NodeKind

fn clone(&self) -> NodeKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeKind

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

Formats the value using the given formatter.

impl Hash for NodeKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for NodeKind

fn eq(&self, other: &NodeKind) -> 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 Copy for NodeKind

impl Eq for NodeKind

impl StructuralPartialEq for NodeKind