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
Interface DependencyNode

All Superinterfaces:
  Comparable<ComparableNode>, ComparableNode, Element

All Known Subinterfaces:
  TokenNode

All Known Implementing Classes:
  Root, Token

    public interface DependencyNode

extends ComparableNode

Method Summary
`void` | `addHeadEdgeLabel(LabelSet labelSet)`
`void` | `addHeadEdgeLabel(SymbolTable table, int code)`
`void` | `addHeadEdgeLabel(SymbolTable table, String symbol)`
`DependencyNode` | `findComponent()`
`DependencyNode` | `getAncestor()`
`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.
`DependencyNode` | `getComponent()`
`int` | `getDependencyNodeDepth()` Returns the depth of the node.
`DependencyNode` | `getHead()` Returns the head dependency node if it exists, otherwise null.
`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()`
`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()`
`DependencyNode` | `getLeftSibling()` Returns the left sibling if it exists, otherwise `null`
`DependencyNode` | `getProperAncestor()`
`int` | `getRank()`
`DependencyNode` | `getRightDependent(int index)`
`int` | `getRightDependentCount()` Return the number of right dependents
`SortedSet<DependencyNode>` | `getRightDependents()` Returns a sorted set of right dependents.
`DependencyNode` | `getRightmostDependent()`
`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()`
`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` | `hasRightDependent()`
`boolean` | `isHeadEdgeLabeled()`
`boolean` | `isProjective()` Returns true if the head edge is projective, otherwise false.
`int` | `nHeadEdgeLabels()`
`void` | `setComponent(DependencyNode x)`
`void` | `setRank(int r)`

Methods inherited from interface org.maltparser.core.syntaxgraph.node.ComparableNode
`getCompareToIndex, getIncomingSecondaryEdges, getInDegree, getIndex, getLeftmostDescendant, getLeftmostDescendantIndex, getLeftmostProperDescendant, getLeftmostProperDescendantIndex, getOutDegree, getOutgoingSecondaryEdges, getRightmostDescendant, getRightmostDescendantIndex, getRightmostProperDescendant, getRightmostProperDescendantIndex, isRoot`

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

Methods inherited from interface java.lang.Comparable
`compareTo`

Method Detail

### hasAtMostOneHead

    boolean hasAtMostOneHead()

  Returns true if the node has at most one head, otherwise false.

  Returns:
    true if the node has at most one head, otherwise false.

### hasHead

    boolean hasHead()

  Returns true if the node has one or more head(s), otherwise false.

  Returns:
    true if the node has one or more head(s), otherwise false.

### getHeads

    Set<DependencyNode> getHeads()
                                 throws MaltChainedException

  Throws:
    `MaltChainedException`

### getHeadEdges

    Set<Edge> getHeadEdges()
                           throws MaltChainedException

  Throws:
    `MaltChainedException`

### getHead

    DependencyNode getHead()
                           throws MaltChainedException

  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.

  Returns:
    the head dependency node if it exists, otherwise null.
  Throws:
    `MaltChainedException`

### getHeadEdge

    Edge getHeadEdge()
                     throws MaltChainedException

  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.

  Returns:
    the edge between the head and the node if it exists, otherwise null.
  Throws:
    `MaltChainedException`

### hasAncestorInside

    boolean hasAncestorInside(int left,
                              int right)
                              throws MaltChainedException

  Throws:
    `MaltChainedException`

### addHeadEdgeLabel

    void addHeadEdgeLabel(SymbolTable table,
                          String symbol)
                          throws MaltChainedException

  Throws:
    `MaltChainedException`

### addHeadEdgeLabel

    void addHeadEdgeLabel(SymbolTable table,
                          int code)
                          throws MaltChainedException

  Throws:
    `MaltChainedException`

### addHeadEdgeLabel

    void addHeadEdgeLabel(LabelSet labelSet)
                          throws MaltChainedException

  Throws:
    `MaltChainedException`

### hasHeadEdgeLabel

    boolean hasHeadEdgeLabel(SymbolTable table)
                             throws MaltChainedException

  Throws:
    `MaltChainedException`

### getHeadEdgeLabelSymbol

    String getHeadEdgeLabelSymbol(SymbolTable table)
                                  throws MaltChainedException

  Throws:
    `MaltChainedException`

### getHeadEdgeLabelCode

    int getHeadEdgeLabelCode(SymbolTable table)
                             throws MaltChainedException

  Throws:
    `MaltChainedException`

### isHeadEdgeLabeled

    boolean isHeadEdgeLabeled()
                              throws MaltChainedException

  Throws:
    `MaltChainedException`

### nHeadEdgeLabels

    int nHeadEdgeLabels()
                        throws MaltChainedException

  Throws:
    `MaltChainedException`

### getHeadEdgeLabelTypes

    Set<SymbolTable> getHeadEdgeLabelTypes()
                                           throws MaltChainedException

  Throws:
    `MaltChainedException`

### getHeadEdgeLabelSet

    LabelSet getHeadEdgeLabelSet()
                                 throws MaltChainedException

  Throws:
    `MaltChainedException`

### getAncestor

    DependencyNode getAncestor()
                               throws MaltChainedException

  Throws:
    `MaltChainedException`

### getProperAncestor

    DependencyNode getProperAncestor()
                                     throws MaltChainedException

  Throws:
    `MaltChainedException`

### hasDependent

    boolean hasDependent()

### hasLeftDependent

    boolean hasLeftDependent()

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

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

### getLeftDependent

    DependencyNode getLeftDependent(int index)

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

  Parameters:
    `index` - the index
  Returns:
    the left dependent at the position index, where index==0 equals the left most dependent

### getLeftDependentCount

    int getLeftDependentCount()

  Return the number of left dependents

  Returns:
    the number of left dependents

### getLeftDependents

    SortedSet<DependencyNode> getLeftDependents()

  Returns a sorted set of left dependents.

  Returns:
    a sorted set of left dependents.

### getLeftSibling

    DependencyNode getLeftSibling()
                                  throws MaltChainedException

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

  Returns:
    the left sibling if it exists, otherwise `null`
  Throws:
    `MaltChainedException`

### getSameSideLeftSibling

    DependencyNode getSameSideLeftSibling()
                                          throws MaltChainedException

  Returns the left sibling at the same side of head as the node it self. If not found `null`
  Returns:
    the left sibling at the same side of head as the node it self. If not found `null` Throws:
    `MaltChainedException`

### getClosestLeftDependent

    DependencyNode getClosestLeftDependent()

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

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

### getLeftmostDependent

    DependencyNode getLeftmostDependent()

### getRightDependent

    DependencyNode getRightDependent(int index)

### getRightDependentCount

    int getRightDependentCount()

  Return the number of right dependents

  Returns:
    the number of right dependents

### getRightDependents

    SortedSet<DependencyNode> getRightDependents()

  Returns a sorted set of right dependents.

  Returns:
    a sorted set of right dependents.

### getRightSibling

    DependencyNode getRightSibling()
                                   throws MaltChainedException

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

  Returns:
    the right sibling if it exists, otherwise `null`
  Throws:
    `MaltChainedException`

### getSameSideRightSibling

    DependencyNode getSameSideRightSibling()
                                           throws MaltChainedException

  Returns the right sibling at the same side of head as the node it self. If not found `null`
  Returns:
    the right sibling at the same side of head as the node it self. If not found `null` Throws:
    `MaltChainedException`

### getClosestRightDependent

    DependencyNode getClosestRightDependent()

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

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

### getRightmostDependent

    DependencyNode getRightmostDependent()

### hasRightDependent

    boolean hasRightDependent()

### isProjective

    boolean isProjective()
                         throws MaltChainedException

  Returns true if the head edge is projective, otherwise false. Undefined if the node has more than one head.

  Returns:
    true if the head edge is projective, otherwise false.
  Throws:
    `MaltChainedException`

### getDependencyNodeDepth

    int getDependencyNodeDepth()
                               throws MaltChainedException

  Returns the depth of the node. The root node has the depth 0.

  Returns:
    the depth of the node.
  Throws:
    `MaltChainedException`

### getRank

    int getRank()

### setRank

    void setRank(int r)

### findComponent

    DependencyNode findComponent()

### getComponent

    DependencyNode getComponent()

### setComponent

    void setComponent(DependencyNode x)

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.