Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| MaltParser 1.6
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.maltparser.core.syntaxgraph.node
Class Root

    java.lang.Object
      java.util.Observable
          org.maltparser.core.syntaxgraph.GraphElement
              org.maltparser.core.syntaxgraph.node.GraphNode
                  org.maltparser.core.syntaxgraph.node.Root

All Implemented Interfaces:
  Comparable<ComparableNode>, Element, ComparableNode, DependencyNode, Node, NonTerminalNode, PhraseStructureNode

    public class Root

extends GraphNode
implements DependencyNode, PhraseStructureNode, NonTerminalNode

Field Summary
`protected SortedSet<PhraseStructureNode>` | `children`
`protected DependencyNode` | `component` a reference to a node where the node is part of a component.
`protected SortedSet<DependencyNode>` | `leftDependents`
`protected int` | `rank`
`protected SortedSet<DependencyNode>` | `rightDependents`

Fields inherited from class org.maltparser.core.syntaxgraph.node.GraphNode
`incomingEdges, outgoingEdges`

Constructor Summary
`Root()`

Method Summary
`void` | `addHeadEdgeLabel(LabelSet labelSet)`
`void` | `addHeadEdgeLabel(SymbolTable table, int code)`
`void` | `addHeadEdgeLabel(SymbolTable table, String symbol)`
`void` | `addIncomingEdge(Edge in)`
`void` | `addOutgoingEdge(Edge out)`
`void` | `clear()` Resets the graph element.
`int` | `compareTo(ComparableNode o)`
`boolean` | `equals(Object obj)`
`DependencyNode` | `findComponent()`
`DependencyNode` | `getAncestor()`
`PhraseStructureNode` | `getChild(int index)`
`SortedSet<PhraseStructureNode>` | `getChildren()`
`DependencyNode` | `getClosestLeftDependent()` Returns the closest left dependent to the node it self, if not found `null` is returned.
`DependencyNode` | `getClosestRightDependent()` Returns the closest right dependent to the node it self, if not found `null` is returned.
`int` | `getCompareToIndex()` Returns the index of the node (only used internal by compareTo).
`DependencyNode` | `getComponent()`
`protected void` | `getDependencyDominationSet(SortedSet<DependencyNode> dominationSet)`
`int` | `getDependencyNodeDepth()` Returns the depth of the node.
`DependencyNode` | `getHead()` Returns the head dependency node if it exists, otherwise null.
`PhraseStructureNode` | `getHeadChild()`
`PhraseStructureNode` | `getHeadChild(HeadRules headRules)`
`Edge` | `getHeadEdge()` Returns the edge between the head and the node if it exists, otherwise null.
`int` | `getHeadEdgeLabelCode(SymbolTable table)`
`LabelSet` | `getHeadEdgeLabelSet()`
`String` | `getHeadEdgeLabelSymbol(SymbolTable table)`
`Set<SymbolTable>` | `getHeadEdgeLabelTypes()`
`Set<Edge>` | `getHeadEdges()`
`Set<DependencyNode>` | `getHeads()`
`int` | `getHeight()`
`int` | `getIndex()` Returns the index of the node.
`PhraseStructureNode` | `getLeftChild()`
`DependencyNode` | `getLeftDependent(int index)` Returns the left dependent at the position `index`, where `index==0` equals the left most dependent.
`int` | `getLeftDependentCount()` Return the number of left dependents
`SortedSet<DependencyNode>` | `getLeftDependents()` Returns a sorted set of left dependents.
`DependencyNode` | `getLeftmostDependent()`
`ComparableNode` | `getLeftmostDescendant()` Returns the left-most terminal descendant node.
`ComparableNode` | `getLeftmostProperDescendant()` Returns the left-most proper terminal descendant node (excluding itself).
`DependencyNode` | `getLeftSibling()` Returns the left sibling if it exists, otherwise `null`
`TokenNode` | `getLexicalHead()`
`TokenNode` | `getLexicalHead(HeadRules headRules)`
`PhraseStructureNode` | `getParent()`
`Edge` | `getParentEdge()`
`int` | `getParentEdgeLabelCode(SymbolTable table)`
`String` | `getParentEdgeLabelSymbol(SymbolTable table)`
`DependencyNode` | `getProperAncestor()`
`int` | `getRank()`
`PhraseStructureNode` | `getRightChild()`
`DependencyNode` | `getRightDependent(int index)`
`int` | `getRightDependentCount()` Return the number of right dependents
`SortedSet<DependencyNode>` | `getRightDependents()` Returns a sorted set of right dependents.
`DependencyNode` | `getRightmostDependent()`
`ComparableNode` | `getRightmostDescendant()` Returns the right-most terminal descendant node.
`ComparableNode` | `getRightmostProperDescendant()` Returns the right-most proper terminal descendant node (excluding itself).
`DependencyNode` | `getRightSibling()` Returns the right sibling if it exists, otherwise `null`
`DependencyNode` | `getSameSideLeftSibling()` Returns the left sibling at the same side of head as the node it self.
`DependencyNode` | `getSameSideRightSibling()` Returns the right sibling at the same side of head as the node it self.
`boolean` | `hasAncestorInside(int left, int right)`
`boolean` | `hasAtMostOneHead()` Returns true if the node has at most one head, otherwise false.
`boolean` | `hasDependent()`
`int` | `hashCode()`
`boolean` | `hasHead()` Returns true if the node has one or more head(s), otherwise false.
`boolean` | `hasHeadEdgeLabel(SymbolTable table)`
`boolean` | `hasLeftDependent()` Returns `true` if the node has one or more left dependents, otherwise `false`.
`boolean` | `hasNonTerminalChildren()`
`boolean` | `hasParentEdgeLabel(SymbolTable table)`
`boolean` | `hasRightDependent()` Returns `true` if the node has one or more right dependents, otherwise `false`.
`boolean` | `hasTerminalChildren()`
`TokenNode` | `identifyHead(HeadRules headRules)`
`boolean` | `isContinuous()`
`boolean` | `isContinuousExcludeTerminalsAttachToRoot()`
`boolean` | `isHeadEdgeLabeled()`
`boolean` | `isProjective()` Returns true if the head edge is projective, otherwise false.
`boolean` | `isRoot()` Returns true if the node is a root node, otherwise false.
`int` | `nChildren()`
`int` | `nHeadEdgeLabels()`
`void` | `removeIncomingEdge(Edge in)`
`void` | `removeOutgoingEdge(Edge out)`
`void` | `setComponent(DependencyNode x)`
`void` | `setIndex(int index)`
`void` | `setRank(int r)`
`String` | `toString()`

Methods inherited from class org.maltparser.core.syntaxgraph.node.GraphNode
`getIncomingEdgeIterator, getIncomingSecondaryEdges, getInDegree, getLeftmostDescendantIndex, getLeftmostProperDescendantIndex, getOutDegree, getOutgoingEdgeIterator, getOutgoingSecondaryEdges, getRightmostDescendantIndex, getRightmostProperDescendantIndex`

Methods inherited from class org.maltparser.core.syntaxgraph.GraphElement
`addLabel, addLabel, addLabel, compareTo, getBelongsToGraph, getLabelCode, getLabelSet, getLabelSymbol, getLabelTypes, hasLabel, isLabeled, nLabels, removeLabel, removeLabels, setBelongsToGraph`

Methods inherited from class java.util.Observable
`addObserver, clearChanged, countObservers, deleteObserver, deleteObservers, hasChanged, notifyObservers, notifyObservers, setChanged`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface org.maltparser.core.syntaxgraph.node.ComparableNode
`getIncomingSecondaryEdges, getInDegree, getLeftmostDescendantIndex, getLeftmostProperDescendantIndex, getOutDegree, getOutgoingSecondaryEdges, getRightmostDescendantIndex, getRightmostProperDescendantIndex`

Methods inherited from interface org.maltparser.core.syntaxgraph.Element
`addLabel, addLabel, addLabel, getBelongsToGraph, getLabelCode, getLabelSet, getLabelSymbol, getLabelTypes, hasLabel, isLabeled, nLabels, removeLabel, removeLabels, setBelongsToGraph`

Field Detail

### leftDependents

    protected final SortedSet<DependencyNode> leftDependents

### rightDependents

    protected final SortedSet<DependencyNode> rightDependents

### children

    protected final SortedSet<PhraseStructureNode> children

### component

    protected DependencyNode component

  a reference to a node where the node is part of a component. If the node is unconnected it will reference to it self.

### rank

    protected int rank

Constructor Detail

### Root

    public Root()
         throws MaltChainedException

Throws:
  `MaltChainedException`

Method Detail

### addIncomingEdge

    public void addIncomingEdge(Edge in)
                         throws MaltChainedException

  Specified by:
    `addIncomingEdge` in interface `Node`
  Overrides:
    `addIncomingEdge` in class `GraphNode`
  Throws:
    `MaltChainedException`

### removeIncomingEdge

    public void removeIncomingEdge(Edge in)

  Specified by:
    `removeIncomingEdge` in interface `Node`
  Overrides:
    `removeIncomingEdge` in class `GraphNode`

### addOutgoingEdge

    public void addOutgoingEdge(Edge out)
                         throws MaltChainedException

  Specified by:
    `addOutgoingEdge` in interface `Node`
  Overrides:
    `addOutgoingEdge` in class `GraphNode`
  Throws:
    `MaltChainedException`

### removeOutgoingEdge

    public void removeOutgoingEdge(Edge out)
                            throws MaltChainedException

  Specified by:
    `removeOutgoingEdge` in interface `Node`
  Overrides:
    `removeOutgoingEdge` in class `GraphNode`
  Throws:
    `MaltChainedException`

### getAncestor

    public DependencyNode getAncestor()
                               throws MaltChainedException

  Specified by:
    `getAncestor` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### getProperAncestor

    public DependencyNode getProperAncestor()
                                     throws MaltChainedException

  Specified by:
    `getProperAncestor` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### getRank

    public int getRank()

  Specified by:
    `getRank` in interface `DependencyNode`

### setRank

    public void setRank(int r)

  Specified by:
    `setRank` in interface `DependencyNode`

### findComponent

    public DependencyNode findComponent()

  Specified by:
    `findComponent` in interface `DependencyNode`

### getComponent

    public DependencyNode getComponent()

  Specified by:
    `getComponent` in interface `DependencyNode`

### setComponent

    public void setComponent(DependencyNode x)

  Specified by:
    `setComponent` in interface `DependencyNode`

### isContinuous

    public boolean isContinuous()

  Specified by:
    `isContinuous` in interface `NonTerminalNode`

### isContinuousExcludeTerminalsAttachToRoot

    public boolean isContinuousExcludeTerminalsAttachToRoot()

  Specified by:
    `isContinuousExcludeTerminalsAttachToRoot` in interface `NonTerminalNode`

### getParent

    public PhraseStructureNode getParent()

  Specified by:
    `getParent` in interface `PhraseStructureNode`

### getParentEdge

    public Edge getParentEdge()
                       throws MaltChainedException

  Specified by:
    `getParentEdge` in interface `PhraseStructureNode`
  Throws:
    `MaltChainedException`

### getParentEdgeLabelSymbol

    public String getParentEdgeLabelSymbol(SymbolTable table)
                                    throws MaltChainedException

  Specified by:
    `getParentEdgeLabelSymbol` in interface `PhraseStructureNode`
  Throws:
    `MaltChainedException`

### getParentEdgeLabelCode

    public int getParentEdgeLabelCode(SymbolTable table)
                               throws MaltChainedException

  Specified by:
    `getParentEdgeLabelCode` in interface `PhraseStructureNode`
  Throws:
    `MaltChainedException`

### hasParentEdgeLabel

    public boolean hasParentEdgeLabel(SymbolTable table)
                               throws MaltChainedException

  Specified by:
    `hasParentEdgeLabel` in interface `PhraseStructureNode`
  Throws:
    `MaltChainedException`

### getChildren

    public SortedSet<PhraseStructureNode> getChildren()

  Specified by:
    `getChildren` in interface `NonTerminalNode`

### getChild

    public PhraseStructureNode getChild(int index)

  Specified by:
    `getChild` in interface `NonTerminalNode`

### getLeftChild

    public PhraseStructureNode getLeftChild()

  Specified by:
    `getLeftChild` in interface `NonTerminalNode`

### getRightChild

    public PhraseStructureNode getRightChild()

  Specified by:
    `getRightChild` in interface `NonTerminalNode`

### nChildren

    public int nChildren()

  Specified by:
    `nChildren` in interface `NonTerminalNode`

### hasNonTerminalChildren

    public boolean hasNonTerminalChildren()

  Specified by:
    `hasNonTerminalChildren` in interface `NonTerminalNode`

### hasTerminalChildren

    public boolean hasTerminalChildren()

  Specified by:
    `hasTerminalChildren` in interface `NonTerminalNode`

### getHeight

    public int getHeight()

  Specified by:
    `getHeight` in interface `NonTerminalNode`

### getLexicalHead

    public TokenNode getLexicalHead(HeadRules headRules)
                             throws MaltChainedException

  Specified by:
    `getLexicalHead` in interface `NonTerminalNode`
  Throws:
    `MaltChainedException`

### getHeadChild

    public PhraseStructureNode getHeadChild(HeadRules headRules)
                                     throws MaltChainedException

  Specified by:
    `getHeadChild` in interface `NonTerminalNode`
  Throws:
    `MaltChainedException`

### getLexicalHead

    public TokenNode getLexicalHead()
                             throws MaltChainedException

  Specified by:
    `getLexicalHead` in interface `NonTerminalNode`
  Throws:
    `MaltChainedException`

### getHeadChild

    public PhraseStructureNode getHeadChild()
                                     throws MaltChainedException

  Specified by:
    `getHeadChild` in interface `NonTerminalNode`
  Throws:
    `MaltChainedException`

### identifyHead

    public TokenNode identifyHead(HeadRules headRules)
                           throws MaltChainedException

  Specified by:
    `identifyHead` in interface `NonTerminalNode`
  Throws:
    `MaltChainedException`

### hasAtMostOneHead

    public boolean hasAtMostOneHead()

  Description copied from interface: `DependencyNode`
  Returns true if the node has at most one head, otherwise false.

  Specified by:
    `hasAtMostOneHead` in interface `DependencyNode`
  Returns:
    true if the node has at most one head, otherwise false.

### hasAncestorInside

    public boolean hasAncestorInside(int left,
                                     int right)
                              throws MaltChainedException

  Specified by:
    `hasAncestorInside` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### hasHead

    public boolean hasHead()

  Description copied from interface: `DependencyNode`
  Returns true if the node has one or more head(s), otherwise false.

  Specified by:
    `hasHead` in interface `DependencyNode`
  Returns:
    true if the node has one or more head(s), otherwise false.

### getHead

    public DependencyNode getHead()
                           throws MaltChainedException

  Description copied from interface: `DependencyNode`
  Returns the head dependency node if it exists, otherwise null. If there exists more than one head the first head is returned according to the linear order of the terminals or the root if it is one of the heads.

  Specified by:
    `getHead` in interface `DependencyNode`
  Returns:
    the head dependency node if it exists, otherwise null.
  Throws:
    `MaltChainedException`

### getHeadEdge

    public Edge getHeadEdge()
                     throws MaltChainedException

  Description copied from interface: `DependencyNode`
  Returns the edge between the head and the node if it exists, otherwise null. If there exists more than one head edge the first head edge is returned according to the linear order of the terminals or the root if it is one of the heads.

  Specified by:
    `getHeadEdge` in interface `DependencyNode`
  Returns:
    the edge between the head and the node if it exists, otherwise null.
  Throws:
    `MaltChainedException`

### addHeadEdgeLabel

    public void addHeadEdgeLabel(SymbolTable table,
                                 String symbol)
                          throws MaltChainedException

  Specified by:
    `addHeadEdgeLabel` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### addHeadEdgeLabel

    public void addHeadEdgeLabel(SymbolTable table,
                                 int code)
                          throws MaltChainedException

  Specified by:
    `addHeadEdgeLabel` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### addHeadEdgeLabel

    public void addHeadEdgeLabel(LabelSet labelSet)
                          throws MaltChainedException

  Specified by:
    `addHeadEdgeLabel` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### getHeadEdgeLabelCode

    public int getHeadEdgeLabelCode(SymbolTable table)
                             throws MaltChainedException

  Specified by:
    `getHeadEdgeLabelCode` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### getHeadEdgeLabelSet

    public LabelSet getHeadEdgeLabelSet()
                                 throws MaltChainedException

  Specified by:
    `getHeadEdgeLabelSet` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### getHeadEdgeLabelSymbol

    public String getHeadEdgeLabelSymbol(SymbolTable table)
                                  throws MaltChainedException

  Specified by:
    `getHeadEdgeLabelSymbol` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### getHeadEdgeLabelTypes

    public Set<SymbolTable> getHeadEdgeLabelTypes()
                                           throws MaltChainedException

  Specified by:
    `getHeadEdgeLabelTypes` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### hasHeadEdgeLabel

    public boolean hasHeadEdgeLabel(SymbolTable table)
                             throws MaltChainedException

  Specified by:
    `hasHeadEdgeLabel` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### isHeadEdgeLabeled

    public boolean isHeadEdgeLabeled()
                              throws MaltChainedException

  Specified by:
    `isHeadEdgeLabeled` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### nHeadEdgeLabels

    public int nHeadEdgeLabels()
                        throws MaltChainedException

  Specified by:
    `nHeadEdgeLabels` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### getHeadEdges

    public Set<Edge> getHeadEdges()
                           throws MaltChainedException

  Specified by:
    `getHeadEdges` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### getHeads

    public Set<DependencyNode> getHeads()
                                 throws MaltChainedException

  Specified by:
    `getHeads` in interface `DependencyNode`
  Throws:
    `MaltChainedException`

### hasDependent

    public boolean hasDependent()

  Specified by:
    `hasDependent` in interface `DependencyNode`

### hasLeftDependent

    public boolean hasLeftDependent()

  Returns `true` if the node has one or more left dependents, otherwise `false`.

  Specified by:
    `hasLeftDependent` in interface `DependencyNode`
  Returns:
    `true` if the node has one or more left dependents, otherwise `false`.

### getLeftDependent

    public DependencyNode getLeftDependent(int index)

  Returns the left dependent at the position `index`, where `index==0` equals the left most dependent.

  Specified by:
    `getLeftDependent` in interface `DependencyNode`
  Parameters:
    `index` - the index
  Returns:
    the left dependent at the position `index`, where `index==0` equals the left most dependent

### getLeftDependentCount

    public int getLeftDependentCount()

  Return the number of left dependents

  Specified by:
    `getLeftDependentCount` in interface `DependencyNode`
  Returns:
    the number of left dependents

### getLeftDependents

    public SortedSet<DependencyNode> getLeftDependents()

  Description copied from interface: `DependencyNode`
  Returns a sorted set of left dependents.

  Specified by:
    `getLeftDependents` in interface `DependencyNode`
  Returns:
    a sorted set of left dependents.

### getLeftSibling

    public DependencyNode getLeftSibling()
                                  throws MaltChainedException

  Returns the left sibling if it exists, otherwise `null`

  Specified by:
    `getLeftSibling` in interface `DependencyNode`
  Returns:
    the left sibling if it exists, otherwise `null`
  Throws:
    `MaltChainedException`

### getSameSideLeftSibling

    public DependencyNode getSameSideLeftSibling()
                                          throws MaltChainedException

  Returns the left sibling at the same side of head as the node it self. If not found `null`
  Specified by:
    `getSameSideLeftSibling` in interface `DependencyNode`
  Returns:
    the left sibling at the same side of head as the node it self. If not found `null` Throws:
    `MaltChainedException`

### getClosestLeftDependent

    public DependencyNode getClosestLeftDependent()

  Returns the closest left dependent to the node it self, if not found `null` is returned.

  Specified by:
    `getClosestLeftDependent` in interface `DependencyNode`
  Returns:
    the closest left dependent to the node it self, if not found `null` is returned.

### getLeftmostDependent

    public DependencyNode getLeftmostDependent()

  Specified by:
    `getLeftmostDependent` in interface `DependencyNode`

### getRightDependent

    public DependencyNode getRightDependent(int index)

  Specified by:
    `getRightDependent` in interface `DependencyNode`

### getRightDependentCount

    public int getRightDependentCount()

  Return the number of right dependents

  Specified by:
    `getRightDependentCount` in interface `DependencyNode`
  Returns:
    the number of right dependents

### getRightDependents

    public SortedSet<DependencyNode> getRightDependents()

  Description copied from interface: `DependencyNode`
  Returns a sorted set of right dependents.

  Specified by:
    `getRightDependents` in interface `DependencyNode`
  Returns:
    a sorted set of right dependents.

### getRightSibling

    public DependencyNode getRightSibling()
                                   throws MaltChainedException

  Returns the right sibling if it exists, otherwise `null`

  Specified by:
    `getRightSibling` in interface `DependencyNode`
  Returns:
    the right sibling if it exists, otherwise `null`
  Throws:
    `MaltChainedException`

### getSameSideRightSibling

    public DependencyNode getSameSideRightSibling()
                                           throws MaltChainedException

  Returns the right sibling at the same side of head as the node it self. If not found `null`
  Specified by:
    `getSameSideRightSibling` in interface `DependencyNode`
  Returns:
    the right sibling at the same side of head as the node it self. If not found `null` Throws:
    `MaltChainedException`

### getClosestRightDependent

    public DependencyNode getClosestRightDependent()

  Returns the closest right dependent to the node it self, if not found `null` is returned.

  Specified by:
    `getClosestRightDependent` in interface `DependencyNode`
  Returns:
    the closest right dependent to the node it self, if not found `null` is returned.

### getRightmostDependent

    public DependencyNode getRightmostDependent()

  Specified by:
    `getRightmostDependent` in interface `DependencyNode`

### hasRightDependent

    public boolean hasRightDependent()

  Returns `true` if the node has one or more right dependents, otherwise `false`.

  Specified by:
    `hasRightDependent` in interface `DependencyNode`
  Returns:
    `true` if the node has one or more right dependents, otherwise `false`.

### getDependencyDominationSet

    protected void getDependencyDominationSet(SortedSet<DependencyNode> dominationSet)

### isProjective

    public boolean isProjective()
                         throws MaltChainedException

  Description copied from interface: `DependencyNode`
  Returns true if the head edge is projective, otherwise false. Undefined if the node has more than one head.

  Specified by:
    `isProjective` in interface `DependencyNode`
  Returns:
    true if the head edge is projective, otherwise false.
  Throws:
    `MaltChainedException`

### getDependencyNodeDepth

    public int getDependencyNodeDepth()
                               throws MaltChainedException

  Description copied from interface: `DependencyNode`
  Returns the depth of the node. The root node has the depth 0.

  Specified by:
    `getDependencyNodeDepth` in interface `DependencyNode`
  Returns:
    the depth of the node.
  Throws:
    `MaltChainedException`

### getIndex

    public int getIndex()

  Description copied from interface: `ComparableNode`
  Returns the index of the node.

  Specified by:
    `getIndex` in interface `ComparableNode`
  Specified by:
    `getIndex` in class `GraphNode`
  Returns:
    the index of the node.

### getCompareToIndex

    public int getCompareToIndex()

  Description copied from interface: `ComparableNode`
  Returns the index of the node (only used internal by compareTo).

  Specified by:
    `getCompareToIndex` in interface `ComparableNode`
  Returns:
    the index of the node (only used internal by compareTo).

### isRoot

    public boolean isRoot()

  Description copied from interface: `ComparableNode`
  Returns true if the node is a root node, otherwise false.

  Specified by:
    `isRoot` in interface `ComparableNode`
  Specified by:
    `isRoot` in class `GraphNode`
  Returns:
    true if the node is a root node, otherwise false.

### getLeftmostProperDescendant

    public ComparableNode getLeftmostProperDescendant()
                                               throws MaltChainedException

  Description copied from interface: `ComparableNode`
  Returns the left-most proper terminal descendant node (excluding itself).

  Specified by:
    `getLeftmostProperDescendant` in interface `ComparableNode`
  Returns:
    the left-most proper terminal descendant node.
  Throws:
    `MaltChainedException`

### getRightmostProperDescendant

    public ComparableNode getRightmostProperDescendant()
                                                throws MaltChainedException

  Description copied from interface: `ComparableNode`
  Returns the right-most proper terminal descendant node (excluding itself).

  Specified by:
    `getRightmostProperDescendant` in interface `ComparableNode`
  Returns:
    the right-most proper terminal descendant node.
  Throws:
    `MaltChainedException`

### getLeftmostDescendant

    public ComparableNode getLeftmostDescendant()
                                         throws MaltChainedException

  Description copied from interface: `ComparableNode`
  Returns the left-most terminal descendant node.

  Specified by:
    `getLeftmostDescendant` in interface `ComparableNode`
  Returns:
    the left-most terminal descendant node.
  Throws:
    `MaltChainedException`

### getRightmostDescendant

    public ComparableNode getRightmostDescendant()
                                          throws MaltChainedException

  Description copied from interface: `ComparableNode`
  Returns the right-most terminal descendant node.

  Specified by:
    `getRightmostDescendant` in interface `ComparableNode`
  Returns:
    the right-most terminal descendant node.
  Throws:
    `MaltChainedException`

### setIndex

    public void setIndex(int index)
                  throws MaltChainedException

  Specified by:
    `setIndex` in interface `Node`
  Specified by:
    `setIndex` in class `GraphNode`
  Throws:
    `MaltChainedException`

### clear

    public void clear()
               throws MaltChainedException

  Description copied from class: `GraphElement`
  Resets the graph element.

  Specified by:
    `clear` in interface `Element`
  Overrides:
    `clear` in class `GraphNode`
  Throws:
    `MaltChainedException`

### compareTo

    public int compareTo(ComparableNode o)

  Specified by:
    `compareTo` in interface `Comparable<ComparableNode>`
  Overrides:
    `compareTo` in class `GraphNode`

### equals

    public boolean equals(Object obj)

  Overrides:
    `equals` in class `GraphNode`

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `GraphNode`

### toString

    public String toString()

  Overrides:
    `toString` in class `GraphNode`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| MaltParser 1.6
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright 2007-2011 Johan Hall, Jens Nilsson and Joakim Nivre.