Struct antlr_rust::tree::LeafNode

[+] Show declaration

pub struct LeafNode<'input, Node: ParserNodeType<'input>, T: 'static> {
    pub symbol: <Node::TF as TokenFactory<'input>>::Tok,
    // some fields omitted
}

[−] Expand description

Generic leaf AST node

Fields

symbol: <Node::TF as TokenFactory<'input>>::Tok

[−] Expand description

Token, this leaf consist of

Implementations

impl<'input, Node: ParserNodeType<'input>, T: 'static> LeafNode<'input, Node, T>[−]

pub fn new(symbol: <Node::TF as TokenFactory<'input>>::Tok) -> Self[−]

creates new leaf node

Trait Implementations

impl<'input, Node: ParserNodeType<'input>, T: 'static> CustomRuleContext<'input> for LeafNode<'input, Node, T>[+]

[+] Show hidden undocumented items

type TF = Node::TF

type Ctx = Node

Type that describes type of context nodes, stored in this context

pub fn get_rule_index(&self) -> usize[−]

Rule index that corresponds to this context type

pub fn get_alt_number(&self) -> isize

pub fn set_alt_number(&self, _alt_number: isize)

impl<'input, Node: ParserNodeType<'input>, T: 'static> Debug for LeafNode<'input, Node, T>[+]

[+] Show hidden undocumented items

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

Formats the value using the given formatter.

impl<'input, Node: ParserNodeType<'input>, T: 'static> NodeText for LeafNode<'input, Node, T>[+]

[+] Show hidden undocumented items

pub fn get_node_text(&self, _rule_names: &[&str]) -> String[−]

Returns text representation of current node type, rule name for context nodes and token text for terminal nodes

impl<'input, Node: ParserNodeType<'input>, T: 'static> ParseTree<'input> for LeafNode<'input, Node, T>[+]

[+] Show hidden undocumented items

pub fn get_source_interval(&self) -> Interval[−]

Return an {@link Interval} indicating the index in the {@link TokenStream} of the first and last token associated with this subtree. If this node is a leaf, then the interval represents a single token and has interval i..i for token index i.

pub fn get_text(&self) -> String[−]

Return combined text of this AST node. To create resulting string it does traverse whole subtree, also it includes only tokens added to the parse tree

pub fn to_string_tree(
    &self,
    r: &dyn Recognizer<'input, TF = Self::TF, Node = Self::Ctx>
) -> String[−]

Print out a whole tree, not just a node, in LISP format (root child1 .. childN). Print just a node if this is a leaf. We have to know the recognizer so we can get rule names.

impl<'input, Node: ParserNodeType<'input> + TidAble<'input>, T: 'static + TidAble<'input>> ParserRuleContext<'input> for LeafNode<'input, Node, T>[+]

[+] Show hidden undocumented items

pub fn set_exception(&self, _e: ANTLRError)

pub fn set_start(&self, _t: Option<<Self::TF as TokenFactory<'input>>::Tok>)

pub fn start<'a>(&'a self) -> Ref<'a, <Self::TF as TokenFactory<'input>>::Inner> where
    'input: 'a, [−]

Get the initial token in this context. Note that the range from start to stop is inclusive, so for rules that do not consume anything (for example, zero length or error productions) this token may exceed stop.

pub fn start_mut<'a>(
    &'a self
) -> RefMut<'a, <Self::TF as TokenFactory<'input>>::Tok> where
    'input: 'a, 

pub fn set_stop(&self, _t: Option<<Self::TF as TokenFactory<'input>>::Tok>)

pub fn stop<'a>(&'a self) -> Ref<'a, <Self::TF as TokenFactory<'input>>::Inner> where
    'input: 'a, [−]

Get the final token in this context. Note that the range from start to stop is inclusive, so for rules that do not consume anything (for example, zero length or error productions) this token may precede start.

pub fn stop_mut<'a>(
    &'a self
) -> RefMut<'a, <Self::TF as TokenFactory<'input>>::Tok> where
    'input: 'a, 

pub fn add_child(&self, _child: Rc<<Self::Ctx as ParserNodeType<'input>>::Type>)

pub fn remove_last_child(&self)

pub fn child_of_type<T>(&self, pos: usize) -> Option<Rc<T>> where
    T: ParserRuleContext<'input, TF = Self::TF, Ctx = Self::Ctx> + 'input,
    Self: Sized, 

pub fn children_of_type<T>(&self) -> Vec<Rc<T>> where
    T: ParserRuleContext<'input, TF = Self::TF, Ctx = Self::Ctx> + 'input,
    Self: Sized, 

pub fn get_token(
    &self,
    ttype: isize,
    pos: usize
) -> Option<Rc<TerminalNode<'input, Self::Ctx>>>

pub fn get_tokens(
    &self,
    ttype: isize
) -> Vec<Rc<TerminalNode<'input, Self::Ctx>>>

impl<'input, Node: ParserNodeType<'input>, T: 'static> RuleContext<'input> for LeafNode<'input, Node, T>[+]

[+] Show hidden undocumented items

pub fn get_invoking_state(&self) -> isize[−]

Internal parser state

pub fn set_invoking_state(&self, _t: isize)[−]

Sets internal parser state

pub fn is_empty(&self) -> bool[−]

A context is empty if there is no invoking state; meaning nobody called current context. Which is usually true for the root of the syntax tree

pub fn get_parent_ctx(
    &self
) -> Option<Rc<<Self::Ctx as ParserNodeType<'input>>::Type>>[−]

Get parent context

pub fn set_parent(
    &self,
    _parent: &Option<Rc<<Self::Ctx as ParserNodeType<'input>>::Type>>
)[−]

Set parent context

impl<'input, Node: ParserNodeType<'input>, T: 'static> TidAble<'input> for LeafNode<'input, Node, T> where
    Node: TidAble<'input>, 

type Static = __LeafNodeinputNodeT_should_never_exist<Node::Static, T>

impl<'input, Node: ParserNodeType<'input>, T: 'static> Tree<'input> for LeafNode<'input, Node, T>[+]

[+] Show hidden undocumented items

pub fn get_parent(
    &self
) -> Option<Rc<<Self::Ctx as ParserNodeType<'input>>::Type>>

pub fn has_parent(&self) -> bool

pub fn get_payload(&self) -> Box<dyn Any>

pub fn get_child(
    &self,
    _i: usize
) -> Option<Rc<<Self::Ctx as ParserNodeType<'input>>::Type>>

pub fn get_child_count(&self) -> usize

pub fn get_children<'a>(
    &'a self
) -> Box<dyn Iterator<Item = Rc<<Self::Ctx as ParserNodeType<'input>>::Type>> + 'a> where
    'input: 'a,