Once constructed, a node's 'parent' and 'previous' references are immutable.
The list of children nodes however can change. When the alternative parsers
in an or parser are attempted one after another, they each generate new child node of
the parent node. These "alternative" nodes all point to the same parent and same "previous" node.
When exception is to be thrown, the most relevant error is picked, along with the tree node
that was recorded at time of ParseContext#raise. That tree node is then
frozen by setting its parent's latestChild to this error
node's "previous" successful node, and that of its grandparent's to its parent node, all the way
up to the root. This essentially freezes and collapse the "multi universes" into a single error
state, with all other "potential" error state destroyed and forgotten.
| Modifier and Type | Field and Description |
|---|---|
| private final int | |
| private int | |
| pack-priv TreeNode | |
| private final String | |
| private final TreeNode | |
| private final TreeNode | |
| private Object |
| Access | Constructor and Description |
|---|---|
| pack-priv | |
| pack-priv |
| Modifier and Type | Method and Description |
|---|---|
| pack-priv TreeNode | |
| pack-priv TreeNode | freeze(int index)
Freezes the current tree node to make it the latest child of its parent (discarding nodes that have been tacked on after it in the same hierarchy level); and recursively apply to all of its ancestors. |
| pack-priv TreeNode | orphanize()
When this leaf node has errors, it didn't complete and shouldn't be part of the parse tree that is the current partial parse result with all successful matches. |
| pack-priv TreeNode | |
| pack-priv void | |
| pack-priv void | |
| pack-priv ParseTree | |
| public String |
| beginIndex | back to summary |
|---|---|
| private final int beginIndex | |
| endIndex | back to summary |
|---|---|
| private int endIndex | |
| latestChild | back to summary |
|---|---|
| pack-priv TreeNode latestChild | |
| name | back to summary |
|---|---|
| private final String name | |
| parent | back to summary |
|---|---|
| private final TreeNode parent | |
| previous | back to summary |
|---|---|
| private final TreeNode previous | |
| result | back to summary |
|---|---|
| private Object result | |
| TreeNode | back to summary |
|---|---|
| pack-priv TreeNode(String name, int beginIndex) | |
| TreeNode | back to summary |
|---|---|
| pack-priv TreeNode(String name, int beginIndex, TreeNode parent, TreeNode previous) | |
| addChild | back to summary |
|---|---|
| pack-priv TreeNode addChild(String childName, int childIndex) | |
| freeze | back to summary |
|---|---|
| pack-priv TreeNode freeze(int index) Freezes the current tree node to make it the latest child of its parent (discarding nodes that have been tacked on after it in the same hierarchy level); and recursively apply to all of its ancestors. This is because it's only called at time of error. If an ancestor node has a child node that was added during the process of trying other alternatives and then failed, those paths don't matter. So we should restore the tree back to when this most relevant error happened. Returns the root node, which can then be used to | |
| orphanize | back to summary |
|---|---|
| pack-priv TreeNode orphanize() When this leaf node has errors, it didn't complete and shouldn't be part of the parse tree
that is the current partial parse result with all successful matches.
In that case, return the parent node, by setting its | |
| parent | back to summary |
|---|---|
| pack-priv TreeNode parent() | |
| setEndIndex | back to summary |
|---|---|
| pack-priv void setEndIndex(int index) | |
| setResult | back to summary |
|---|---|
| pack-priv void setResult(Object result) | |
| toParseTree | back to summary |
|---|---|
| pack-priv ParseTree toParseTree() Converts this node into a | |
| toString | back to summary |
|---|---|
| public String toString() Overrides java. Doc from java. Returns a string representation of the object.
Satisfying this method's contract implies a non- | |