Package opennlp.tools.parser

# Class Parse

java.lang.Object
opennlp.tools.parser.Parse

All Implemented Interfaces:
  `Cloneable`, `Comparable<Parse>`

public class Parse extends Object implements Cloneable, Comparable<Parse>
Data structure for holding parse constituents.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final String`
  `BRACKET_LCB`
  `static final String`
  `BRACKET_LRB`
  `static final String`
  `BRACKET_LSB`
  `static final String`
  `BRACKET_RCB`
  `static final String`
  `BRACKET_RRB`
  `static final String`
  `BRACKET_RSB`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `Parse(String text, Span span, String type, double p, int index)`
  Initializes a `node` for this specified `text` and `span` of the specified `type` with probability `p` and the head `index`.
  `Parse(String text, Span span, String type, double p, Parse h)`
  Initializes a `node` for this specified `text` and `span` of the specified `type` with probability `p` and the head `index`.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `add(Parse daughter, HeadRules rules)`
  `static void`
  `addNames(String tag, Span[] names, Parse[] tokens)`
  Utility method to insert named entities.
  `void`
  `addNextPunctuation(Parse punct)`
  Designates that the specified punctuation follows this parse.
  `void`
  `addPreviousPunctuation(Parse punct)`
  Designates that the specified punctuation should is prior to this parse.
  `void`
  `addProb(double logProb)`
  Adds the specified `logProb` to this current log for this parse.
  `Parse`
  `adjoin(Parse sister, HeadRules rules)`
  Sister adjoins this node's last child and the specified sister node and returns their new parent node.
  `Parse`
  `adjoinRoot(Parse node, HeadRules rules, int parseIndex)`
  `Object`
  `clone()`
  `Parse`
  `clone(Parse node)`
  Clones the right frontier of `Parse` up to the specified `node`.
  `Parse`
  `cloneRoot(Parse node, int parseIndex)`
  Clones the right frontier of this root `Parse` up to and including the specified node.
  `int`
  `compareTo(Parse p)`
  `boolean`
  `complete()`
  `static Parse`
  `createFromTokens(String[] tokens)`
  Creates a `Parse` structure from an array of pre-tokenized strings.
  `boolean`
  `equals(Object obj)`
  `void`
  `expandTopNode(Parse root)`
  `static void`
  `fixPossesives(Parse parse)`
  `int`
  `getChildCount()`
  `Parse[]`
  `getChildren()`
  `Parse`
  `getCommonParent(Parse node)`
  Returns the deepest shared parent of this node and the specified node.
  `String`
  `getCoveredText()`
  `StringBuffer`
  `getDerivation()`
  `Parse`
  `getHead()`
  `int`
  `getHeadIndex()`
  `String`
  `getLabel()`
  Retrieves the label assigned to this parse node during parsing which specifies how this node will be formed into a constituent.
  `Collection<Parse>`
  `getNextPunctuationSet()`
  `Parse`
  `getParent()`
  `Collection<Parse>`
  `getPreviousPunctuationSet()`
  `double`
  `getProb()`
  `Span`
  `getSpan()`
  `Parse[]`
  `getTagNodes()`
  `double`
  `getTagSequenceProb()`
  `String`
  `getText()`
  `Parse[]`
  `getTokenNodes()`
  `String`
  `getType()`
  `int`
  `hashCode()`
  `int`
  `indexOf(Parse child)`
  `void`
  `insert(Parse constituent)`
  Inserts the specified constituent into this parse based on its text span.
  `boolean`
  `isChunk()`
  `void`
  `isChunk(boolean ic)`
  `boolean`
  `isFlat()`
  Indicates whether this parse node contains no sub-constituents.
  `boolean`
  `isPosTag()`
  Indicates whether this parse node is a pos-tag.
  `static Parse`
  `parseParse(String parse)`
  Parses the specified tree-bank style parse string and return a `Parse` structure for that string.
  `static Parse`
  `parseParse(String parse, GapLabeler gl)`
  Parses the specified tree-bank style `Parse` string and return a `Parse` structure for that string.
  `static void`
  `pruneParse(Parse parse)`
  Prune the specified sentence parse of vacuous productions.
  `void`
  `remove(int index)`
  `void`
  `setChild(int index, String label)`
  Replaces the child at the specified index with a new child with the specified label.
  `void`
  `setDerivation(StringBuffer derivation)`
  Specifies the derivation string to be associated with this parse.
  `void`
  `setLabel(String label)`
  Assigns this parse the specified label.
  `void`
  `setNextPunctuation(Collection<Parse> punctSet)`
  Sets the `punctuation tags` which follow this parse.
  `void`
  `setParent(Parse parent)`
  Specifies the parent parse node for this constituent.
  `void`
  `setPrevPunctuation(Collection<Parse> punctSet)`
  Sets the `punctuation tags` which precede this parse.
  `void`
  `setType(String type)`
  Set the type of this constituent to the specified type.
  `void`
  `show()`
  Prints this parse using Penn Treebank-style formatting.
  `void`
  `show(StringBuffer sb)`
  Fills the specified `StringBuffer` with a string representation of this parse.
  `void`
  `showCodeTree()`
  Prints to standard out a representation of the specified parse which contains hash codes so that parent/child relationships can be explicitly seen.
  `String`
  `toString()`
  Represents this `Parse` in a human-readable way.
  `String`
  `toStringPennTreebank()`
  `void`
  `updateHeads(HeadRules rules)`
  Computes the head parses for this parse and its sub-parses and stores this information in the parse data structure.
  `void`
  `updateSpan()`
  `static void`
  `useFunctionTags(boolean uft)`
  Specifies whether function tags should be included as part of the constituent type.

  ### Methods inherited from class java.lang.Object

  `getClass, notify, notifyAll, wait, wait, wait`

- ## Field Details

  - ### BRACKET_LRB

    public static final String BRACKET_LRB
    See Also:
      - Constant Field Values

  - ### BRACKET_RRB

    public static final String BRACKET_RRB
    See Also:
      - Constant Field Values

  - ### BRACKET_LCB

    public static final String BRACKET_LCB
    See Also:
      - Constant Field Values

  - ### BRACKET_RCB

    public static final String BRACKET_RCB
    See Also:
      - Constant Field Values

  - ### BRACKET_LSB

    public static final String BRACKET_LSB
    See Also:
      - Constant Field Values

  - ### BRACKET_RSB

    public static final String BRACKET_RSB
    See Also:
      - Constant Field Values

- ## Constructor Details

  - ### Parse

    public Parse(String text, Span span, String type, double p, int index)
    Initializes a `node` for this specified `text` and `span` of the specified `type` with probability `p` and the head `index`.
    Parameters:
      `text` - The text of the sentence for which this node is a part of.
      `span` - The `character offsets` for this node within the specified `text`.
      `type` - The constituent label of this node.
      `p` - The probability of this `Parse`.
      `index` - The token index of the head of this parse.

  - ### Parse

    public Parse(String text, Span span, String type, double p, Parse h)
    Initializes a `node` for this specified `text` and `span` of the specified `type` with probability `p` and the head `index`.
    Parameters:
      `text` - The text of the sentence for which this node is a part of.
      `span` - The `character offsets` for this node within the specified `text`.
      `type` - The constituent label of this node.
      `p` - The probability of this parse.
      `h` - The head token of this parse.

- ## Method Details

  - ### clone

    public Object clone()

  - ### clone

    public Parse clone(Parse node)
    Clones the right frontier of `Parse` up to the specified `node`.
    Parameters:
      `node` - The last `node` in the right frontier of the parse tree to be cloned.
    Returns:
      A clone of this parse and its right frontier up to and including the specified node.

  - ### cloneRoot

    public Parse cloneRoot(Parse node, int parseIndex)
    Clones the right frontier of this root `Parse` up to and including the specified node.
    Parameters:
      `node` - The last `node` in the right frontier of the parse tree to be cloned.
      `parseIndex` - The child index of the parse for this root `node`.
    Returns:
      A clone of this root parse and its right frontier up to and including the specified node.

  - ### useFunctionTags

    public static void useFunctionTags(boolean uft)
    Specifies whether function tags should be included as part of the constituent type.
    Parameters:
      `uft` - `true` is they should be included, `false` otherwise.

  - ### setType

    public void setType(String type)
    Set the type of this constituent to the specified type.
    Parameters:
      `type` - The type of this constituent.

  - ### getType

    public String getType()
    Returns:
      Retrieves the constituent label for this node of the parse.

  - ### getPreviousPunctuationSet

    public Collection<Parse> getPreviousPunctuationSet()
    Returns:
      Retrieves the set of punctuation `parses` that occur immediately before this parse.

  - ### addPreviousPunctuation

    public void addPreviousPunctuation(Parse punct)
    Designates that the specified punctuation should is prior to this parse.
    Parameters:
      `punct` - The `punctuation` to be added.

  - ### getNextPunctuationSet

    public Collection<Parse> getNextPunctuationSet()
    Returns:
      Retrieves the set of punctuation `parses` that occur immediately after this parse.

  - ### addNextPunctuation

    public void addNextPunctuation(Parse punct)
    Designates that the specified punctuation follows this parse.
    Parameters:
      `punct` - The `punctuation` set.

  - ### setNextPunctuation

    public void setNextPunctuation(Collection<Parse> punctSet)
    Sets the `punctuation tags` which follow this parse.
    Parameters:
      `punctSet` - The punctuation tags which follow this parse.

  - ### setPrevPunctuation

    public void setPrevPunctuation(Collection<Parse> punctSet)
    Sets the `punctuation tags` which precede this parse.
    Parameters:
      `punctSet` - The punctuation tags which precede this parse.

  - ### insert

    public void insert(Parse constituent)
    Inserts the specified constituent into this parse based on its text span. This method assumes that the specified constituent can be inserted into this parse.
    Parameters:
      `constituent` - The `constituent` to be inserted.

  - ### show

    public void show(StringBuffer sb)
    Fills the specified `StringBuffer` with a string representation of this parse.
    Parameters:
      `sb` - A `StringBuffer` into which the parse string can be appended.

  - ### show

    public void show()
    Prints this parse using Penn Treebank-style formatting.

  - ### getTagSequenceProb

    public double getTagSequenceProb()
    Returns:
      Retrieves the probability associated with the pos-tag sequence assigned to this parse.

  - ### complete

    public boolean complete()
    Returns:
      `true` if the parse contains a single top-most node (=complete), `false` otherwise.

  - ### getCoveredText

    public String getCoveredText()

  - ### toStringPennTreebank

    public String toStringPennTreebank()
    Returns:
      Retrieves a String representation using Penn Treebank-style formatting.

  - ### toString

    public String toString()
    Represents this `Parse` in a human-readable way.
    Overrides:
      `toString` in class `Object`

  - ### getText

    public String getText()
    Returns:
      Retrieves the text of the sentence over which this parse was formed.

  - ### getSpan

    public Span getSpan()
    Returns:
      Retrieves the `character offsets` for this constituent.

  - ### getProb

    public double getProb()
    Returns:
      Retrieves the `log` of the product of the probability associated with all the decisions which formed this constituent.

  - ### addProb

    public void addProb(double logProb)
    Adds the specified `logProb` to this current log for this parse.
    Parameters:
      `logProb` - The probability of an action performed on this parse.

  - ### getChildren

    public Parse[] getChildren()
    Returns:
      Retrieves the `child constituents` of this constituent.

  - ### setChild

    public void setChild(int index, String label)
    Replaces the child at the specified index with a new child with the specified label.
    Parameters:
      `index` - The index of the child to be replaced.
      `label` - The label to be assigned to the new child.

  - ### add

    public void add(Parse daughter, HeadRules rules)

  - ### remove

    public void remove(int index)

  - ### adjoinRoot

    public Parse adjoinRoot(Parse node, HeadRules rules, int parseIndex)

  - ### adjoin

    public Parse adjoin(Parse sister, HeadRules rules)
    Sister adjoins this node's last child and the specified sister node and returns their new parent node. The new parent node replace this node's last child.
    Parameters:
      `sister` - The `node` to be adjoined.
      `rules` - The `HeadRules` for the parser.
    Returns:
      The new `parent node` of this node and the specified sister node.

  - ### expandTopNode

    public void expandTopNode(Parse root)

  - ### getChildCount

    public int getChildCount()
    Returns:
      Retrieves the number of children for this parse node.

  - ### indexOf

    public int indexOf(Parse child)
    Parameters:
      `child` - A child of this parse.
    Returns:
      Retrieves the index of this specified child or `-1` if the specified child is not a child of this parse.

  - ### getHead

    public Parse getHead()
    Returns:
      Retrieves the head constituent associated with this constituent.

  - ### getHeadIndex

    public int getHeadIndex()
    Returns:
      Retrieves the index within a sentence of the head token for this parse.

  - ### getLabel

    public String getLabel()
    Retrieves the label assigned to this parse node during parsing which specifies how this node will be formed into a constituent.
    Returns:
      The outcome label assigned to this node during parsing.

  - ### setLabel

    public void setLabel(String label)
    Assigns this parse the specified label. This is used by parsing schemes to tag parsing nodes while building.
    Parameters:
      `label` - A label indicating something about the stage of building for this parse node.

  - ### updateHeads

    public void updateHeads(HeadRules rules)
    Computes the head parses for this parse and its sub-parses and stores this information in the parse data structure.
    Parameters:
      `rules` - The `HeadRules` which determine how the head of the parse is computed.

  - ### updateSpan

    public void updateSpan()

  - ### pruneParse

    public static void pruneParse(Parse parse)
    Prune the specified sentence parse of vacuous productions.
    Parameters:
      `parse` - The sentence `Parse`.

  - ### fixPossesives

    public static void fixPossesives(Parse parse)

  - ### createFromTokens

    public static Parse createFromTokens(String[] tokens)
    Creates a `Parse` structure from an array of pre-tokenized strings.

    This is a convenience factory method for cases where the input sentence is already tokenized (e.g., as a `String[]`). It joins the tokens with whitespace, computes character offset `spans` for each token, and builds the initial flat parse tree expected by `Parser.parse(Parse)`.

    Parameters:
      `tokens` - The tokens of the sentence.
    Returns:
      A flat `Parse` structure with token nodes ready for a `Parser`.
    Throws:
      `IllegalArgumentException` - if `tokens` is `null` or empty.

  - ### parseParse

    public static Parse parseParse(String parse)
    Parses the specified tree-bank style parse string and return a `Parse` structure for that string.
    Parameters:
      `parse` - A tree-bank style `Parse` string.
    Returns:
      A `Parse` structure for the specified tree-bank style parse string.

  - ### parseParse

    public static Parse parseParse(String parse, GapLabeler gl)
    Parses the specified tree-bank style `Parse` string and return a `Parse` structure for that string.
    Parameters:
      `parse` - A tree-bank style `Parse` string.
      `gl` - The `GapLabeler` to be used.
    Returns:
      A `Parse` structure for the specified tree-bank style parse string.

  - ### getParent

    public Parse getParent()
    Returns:
      Retrieves the parent parse node of this constituent.

  - ### setParent

    public void setParent(Parse parent)
    Specifies the parent parse node for this constituent.
    Parameters:
      `parent` - The parent parse node for this constituent.

  - ### isPosTag

    public boolean isPosTag()
    Indicates whether this parse node is a pos-tag.
    Returns:
      `true` if this node is a pos-tag, `false` otherwise.

  - ### isFlat

    public boolean isFlat()
    Indicates whether this parse node contains no sub-constituents.
    Returns:
      `true` if this constituent contains no sub-constituents; `false` otherwise.

  - ### isChunk

    public void isChunk(boolean ic)

  - ### isChunk

    public boolean isChunk()

  - ### getTagNodes

    public Parse[] getTagNodes()
    Returns:
      Retrieves the parse nodes which are children of this node and which are pos tags.

  - ### getTokenNodes

    public Parse[] getTokenNodes()

  - ### getCommonParent

    public Parse getCommonParent(Parse node)
    Returns the deepest shared parent of this node and the specified node. If the nodes are identical then their parent is returned. If one node is the parent of the other than the parent node is returned.
    Parameters:
      `node` - The node from which parents are compared to this node's parents.
    Returns:
      the deepest shared parent of this node and the specified node.

  - ### equals

    public boolean equals(Object obj)
    Overrides:
      `equals` in class `Object`

  - ### hashCode

    public int hashCode()
    Overrides:
      `hashCode` in class `Object`

  - ### compareTo

    public int compareTo(Parse p)
    Specified by:
      `compareTo` in interface `Comparable<Parse>`

  - ### getDerivation

    public StringBuffer getDerivation()
    Returns:
      Retrieves the derivation string for this parse or `null` if no derivation string has been created.

  - ### setDerivation

    public void setDerivation(StringBuffer derivation)
    Specifies the derivation string to be associated with this parse.
    Parameters:
      `derivation` - The derivation string to be associated with this parse.

  - ### showCodeTree

    public void showCodeTree()
    Prints to standard out a representation of the specified parse which contains hash codes so that parent/child relationships can be explicitly seen.

  - ### addNames

    public static void addNames(String tag, Span[] names, Parse[] tokens)
    Utility method to insert named entities.
    Parameters:
      `tag` - A token representing a tag.
      `names` - An array of `names`.
      `tokens` - An array of `tokens`.