Enum CstNodeData 

pub enum CstNodeData<T, Nt> {
    Terminal {
        kind: T,
        data: TerminalData,
    },
    NonTerminal {
        kind: Nt,
        data: NonTerminalData,
    },
}

Variants

Terminal

A terminal node with its kind and span

Fields

kind: T

data: TerminalData

NonTerminal

A non-terminal node with its kind

Fields

kind: Nt

data: NonTerminalData

Implementations

impl<T, Nt> CstNodeData<T, Nt>

pub fn new_terminal(kind: T, data: TerminalData) -> Self

pub fn new_non_terminal(kind: Nt, data: NonTerminalData) -> Self

pub fn is_terminal(&self) -> bool

pub fn is_non_terminal(&self) -> bool

impl<T, Nt> CstNodeData<T, Nt>

where T: Copy, Nt: Copy,

pub fn node_kind(&self) -> NodeKind<T, Nt>

impl<T, Nt> CstNodeData<T, Nt>

where T: PartialEq + Copy, Nt: PartialEq + Copy,

pub fn expected_terminal_or_error( &self, node: CstNodeId, expected: T, ) -> Result<(T, TerminalData), ViewConstructionError<T, Nt>>

pub fn expected_non_terminal_or_error( &self, node: CstNodeId, expected: Nt, ) -> Result<(Nt, NonTerminalData), ViewConstructionError<T, Nt>>

Trait Implementations

impl<T: Clone, Nt: Clone> Clone for CstNodeData<T, Nt>

fn clone(&self) -> CstNodeData<T, Nt>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, Nt: Debug> Debug for CstNodeData<T, Nt>

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

Formats the value using the given formatter.

impl<T: Hash, Nt: Hash> Hash for CstNodeData<T, Nt>

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<T: PartialEq, Nt: PartialEq> PartialEq for CstNodeData<T, Nt>

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

impl<T: Eq, Nt: Eq> Eq for CstNodeData<T, Nt>

impl<T, Nt> StructuralPartialEq for CstNodeData<T, Nt>