Struct grammartec::tree::Tree

pub struct Tree {
    pub rules: Vec<RuleIDOrCustom>,
    pub sizes: Vec<usize>,
    pub paren: Vec<NodeID>,
}

Fields

rules: Vec<RuleIDOrCustom>

sizes: Vec<usize>

paren: Vec<NodeID>

Implementations

impl Tree

pub fn from_rule_vec(rules: Vec<RuleIDOrCustom>, ctx: &Context) -> Self

pub fn get_rule_id(&self, n: NodeID) -> RuleID

pub fn subtree_size(&self, n: NodeID) -> usize

pub fn mutate_replace_from_tree<'a>( &'a self, n: NodeID, other: &'a Tree, other_node: NodeID ) -> TreeMutation<'a>

pub fn get_parent(&self, n: NodeID) -> Option<NodeID>

pub fn truncate(&mut self)

pub fn generate_from_nt(&mut self, start: NTermID, len: usize, ctx: &Context)

pub fn generate_from_rule( &mut self, ruleid: RuleID, max_len: usize, ctx: &Context )

pub fn calc_recursions(&self, ctx: &Context) -> Option<Vec<RecursionInfo>>

pub fn find_recursions_iter(&self, ctx: &Context) -> Vec<(NodeID, NodeID)>

Trait Implementations

impl Clone for Tree

fn clone(&self) -> Tree

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tree

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tree

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Tree

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TreeLike for Tree

fn get_rule_id(&self, n: NodeID) -> RuleID

fn size(&self) -> usize

fn to_tree(&self, _ctx: &Context) -> Tree

fn get_rule<'c>(&self, n: NodeID, ctx: &'c Context) -> &'c Rule

fn get_custom_rule_data(&self, n: NodeID) -> &[u8]

fn get_rule_or_custom(&self, n: NodeID) -> &RuleIDOrCustom

fn get_nonterm_id(&self, n: NodeID, ctx: &Context) -> NTermID

fn unparse<W: Write>(&self, id: NodeID, ctx: &Context, w: &mut W)

fn unparse_to<W: Write>(&self, ctx: &Context, w: &mut W)

fn unparse_to_vec(&self, ctx: &Context) -> Vec<u8>

fn unparse_node_to_vec(&self, n: NodeID, ctx: &Context) -> Vec<u8>

fn unparse_print(&self, ctx: &Context)