SPPTBranchDefault

class SPPTBranchDefault(runtimeRule: RuntimeRule, option: Int, location: InputLocation, nextInputPosition: Int, priority: Int) : SPPTNodeAbstract, SPPTBranch

Functions

branchChild

common

open override fun branchChild(index: Int): SPPTBranch

contains

common

open override fun contains(other: SPPTNode): Boolean

this leaf contains another leaf if they are equal
this branch contains another branch if all the children alternatives of the other are contained in this

equals

common

open operator override fun equals(other: Any?): Boolean

hashCode

common

open override fun hashCode(): Int

nonSkipChild

common

open override fun nonSkipChild(index: Int): SPPTNode

toString

common

open override fun toString(): String

toStringIndented

common

fun toStringIndented(indentIncrement: String): String

Properties

asBranch

common

open override val asBranch: SPPTBranch

this node cast to an ISPPFBranch (or null if the node is not a branch)

asLeaf

common

open override val asLeaf: SPPTLeaf

this node cast to an ILeaf (or null if the node is not a leaf)

branchNonSkipChildren

common

open override val branchNonSkipChildren: List<SPPTBranch>

Filters out any children that are skip nodes or not branchesall children that are branches and non skip (in first one of the children alternatives)

children

common

open override val children: List<SPPTNode>

the first one of the children alternatives of this branch.

childrenAlternatives

common

open override val childrenAlternatives: MutableSet<List<SPPTNode>>

the set of alternative children for this branch

embeddedIn

common

var embeddedIn: String? = null

identity

common

open override val identity: SPPTNodeIdentity

the identity of this node

isBranch

common

open override val isBranch: Boolean = true

true if this node is a branch

isEmptyLeaf

common

open override val isEmptyLeaf: Boolean = false

an Empty Leaf is constructed by a parse by specifically matching nothing, caused by:

a rule with no items (for example 'rule = ;')
an optional item (for example 'rule = item?

isEmptyMatch

common

open override val isEmptyMatch: Boolean

isLeaf

common

open override val isLeaf: Boolean = false

true if this node is a Leaf

isSkip

common

open override val isSkip: Boolean

a grammar can define some rules as 'skip' rules, for example a rule to match whitespace is commonly a skip rule.

lastLeaf

common

open override val lastLeaf: SPPTLeaf

location

common

open override val location: InputLocation

matchedText

common

open override val matchedText: String

all text matched by this node

matchedTextLength

common

open override val matchedTextLength: Int

the length of the text (in characters) matched by this node, derived from identity

name

common

open override val name: String

the name of the runtime rule that caused this node to be constructed

nextInputPosition

common

open override val nextInputPosition: Int

startPosition + matchedTextLength

nonSkipChildren

common

open override val nonSkipChildren: List<SPPTNode>

the first one of the children alternatives of this branch with all skip nodes removed.

nonSkipMatchedText

common

open override val nonSkipMatchedText: String

all text matched by this node excluding text that was matched by skip rules.

numberOfLines

common

open override val numberOfLines: Int

the number of lines (end of line markers) covered by the text that this node matches

option

common

open override val option: Int

parent

common

open override var parent: SPPTBranch? = null

A parent might be null if the construction of the node has not set it (it is not required)the parent branch of this node.

priority

common

open override val priority: Int

the priority of this node according to the grammar (0 if no priority defined by parent rule)

runtimeRule

common

val runtimeRule: RuntimeRule

runtimeRuleNumber

common

open override val runtimeRuleNumber: Int

the rule number from the runtime grammar that caused this node to be constructed, derived from identity

startPosition

common

open override val startPosition: Int

the index position of the input text at which this node starts its match, derived from identity