Struct GreenNode 

pub struct GreenNode<'a, L>
where
    L: Language,
{
    pub kind: <L as Language>::ElementType,
    pub text_len: u32,
    pub children: &'a [GreenTree<'a, L>],
}

A green node that contains child elements.

Green nodes are allocated in a SyntaxArena and hold a slice reference to their children. They are POD (Plain Old Data) and strictly immutable.

Fields

kind: <L as Language>::ElementType

The element type (kind) of this node.

text_len: u32

The total text length of this node (sum of children’s lengths).

children: &'a [GreenTree<'a, L>]

The children of this node.

Implementations

impl<'a, L> GreenNode<'a, L>

where L: Language,

pub fn new( kind: <L as Language>::ElementType, children: &'a [GreenTree<'a, L>], ) -> GreenNode<'a, L>

Creates a new green node from child elements.

This function assumes the children slice is already allocated in the arena.

pub fn kind(&self) -> <L as Language>::ElementType

Returns the kind of this node.

pub fn text_len(&self) -> u32

Returns the total text length of this node.

pub fn children(&self) -> &'a [GreenTree<'a, L>]

Returns the children of this node.

pub fn child_at(&self, index: usize) -> Option<&'a GreenTree<'a, L>>

Returns a specific child at index.

Trait Implementations

impl<'a, L> Clone for GreenNode<'a, L>

where L: Language,

fn clone(&self) -> GreenNode<'a, L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, L> Debug for GreenNode<'a, L>

where L: Language,

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

Formats the value using the given formatter.

impl<'a, L> Hash for GreenNode<'a, L>

where L: Language,

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

where H: Hasher,

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<'a, L> PartialEq for GreenNode<'a, L>

where L: Language,

fn eq(&self, other: &GreenNode<'a, L>) -> 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<'a, L> Eq for GreenNode<'a, L>

where L: Language,