    001    package org.maltparser.core.syntaxgraph.node;
    002
    003    import java.util.Set;
    004    import java.util.SortedSet;
    005
    006    import org.maltparser.core.exception.MaltChainedException;
    007    import org.maltparser.core.symbol.SymbolTable;
    008    import org.maltparser.core.syntaxgraph.LabelSet;
    009    import org.maltparser.core.syntaxgraph.edge.Edge;
    010
    011
    012
    013    public interface DependencyNode extends ComparableNode {
    014            /**
    015             * Returns <i>true</i> if the node has at most one head, otherwise <i>false</i>.
    016             *
    017             * @return <i>true</i> if the node has at most one head, otherwise <i>false</i>.
    018             */
    019            public boolean hasAtMostOneHead();
    020            /**
    021             * Returns <i>true</i> if the node has one or more head(s), otherwise <i>false</i>.
    022             *
    023             * @return <i>true</i> if the node has one or more head(s), otherwise <i>false</i>.
    024             */
    025            public boolean hasHead();
    026            public Set<DependencyNode> getHeads() throws MaltChainedException;
    027            public Set<Edge> getHeadEdges() throws MaltChainedException;
    028
    029
    030            /**
    031             * Returns the head dependency node if it exists, otherwise <i>null</i>. If there exists more
    032             * than one head the first head is returned according to the linear order of the terminals
    033             * or the root if it is one of the heads.
    034             *
    035             * @return the head dependency node if it exists, otherwise <i>null</i>.
    036             * @throws MaltChainedException
    037             */
    038            public DependencyNode getHead() throws MaltChainedException;
    039            /**
    040             * Returns the edge between the head and the node if it exists, otherwise <i>null</i>. If there exists more
    041             * than one head edge the first head edge is returned according to the linear order of the terminals
    042             * or the root if it is one of the heads.
    043             *
    044             * @return the edge between the head and the node if it exists, otherwise <i>null</i>.
    045             * @throws MaltChainedException
    046             */
    047            public Edge getHeadEdge() throws MaltChainedException;
    048            public boolean hasAncestorInside(int left, int right) throws MaltChainedException;
    049            public void addHeadEdgeLabel(SymbolTable table, String symbol) throws MaltChainedException;
    050            public void addHeadEdgeLabel(SymbolTable table, int code) throws MaltChainedException;
    051            public void addHeadEdgeLabel(LabelSet labelSet) throws MaltChainedException;
    052            public boolean hasHeadEdgeLabel(SymbolTable table) throws MaltChainedException;
    053            public String getHeadEdgeLabelSymbol(SymbolTable table) throws MaltChainedException;
    054            public int getHeadEdgeLabelCode(SymbolTable table) throws MaltChainedException;
    055            public boolean isHeadEdgeLabeled() throws MaltChainedException;
    056            public int nHeadEdgeLabels() throws MaltChainedException;
    057            public Set<SymbolTable> getHeadEdgeLabelTypes() throws MaltChainedException;
    058            public LabelSet getHeadEdgeLabelSet() throws MaltChainedException;
    059            public DependencyNode getAncestor() throws MaltChainedException;
    060            public DependencyNode getProperAncestor() throws MaltChainedException;
    061
    062            public boolean hasDependent();
    063            /**
    064             * Returns <i>true</i> if the node has one or more left dependents, otherwise <i>false</i>.
    065             *
    066             * @return <i>true</i> if the node has one or more left dependents, otherwise <i>false</i>.
    067             */
    068            public boolean hasLeftDependent();
    069            /**
    070             * Returns the left dependent at the position <i>index</i>, where <i>index==0</i> equals the left most dependent.
    071             *
    072             * @param index the index
    073             * @return the left dependent at the position <i>index</i>, where <i>index==0</i> equals the left most dependent
    074             */
    075            public DependencyNode getLeftDependent(int index);
    076            /**
    077             * Return the number of left dependents
    078             *
    079             * @return the number of left dependents
    080             */
    081            public int getLeftDependentCount();
    082            /**
    083             * Returns a sorted set of left dependents.
    084             *
    085             * @return a sorted set of left dependents.
    086             */
    087            public SortedSet<DependencyNode> getLeftDependents();
    088            /**
    089             * Returns the left sibling if it exists, otherwise <code>null</code>
    090             *
    091             * @return the left sibling if it exists, otherwise <code>null</code>
    092             */
    093            public DependencyNode getLeftSibling() throws MaltChainedException;
    094            /**
    095             * Returns the left sibling at the same side of head as the node it self. If not found <code>null</code is returned
    096             *
    097             * @return the left sibling at the same side of head as the node it self. If not found <code>null</code is returned
    098             */
    099            public DependencyNode getSameSideLeftSibling() throws MaltChainedException;
    100            /**
    101             * Returns the closest left dependent to the node it self, if not found <code>null</code> is returned.
    102             *
    103             * @return the closest left dependent to the node it self, if not found <code>null</code> is returned.
    104             */
    105            public DependencyNode getClosestLeftDependent();
    106            public DependencyNode getLeftmostDependent();
    107            public DependencyNode getRightDependent(int index);
    108            /**
    109             * Return the number of right dependents
    110             *
    111             * @return the number of right dependents
    112             */
    113            public int getRightDependentCount();
    114            /**
    115             * Returns a sorted set of right dependents.
    116             *
    117             * @return a sorted set of right dependents.
    118             */
    119            public SortedSet<DependencyNode> getRightDependents();
    120            /**
    121             * Returns the right sibling if it exists, otherwise <code>null</code>
    122             *
    123             * @return the right sibling if it exists, otherwise <code>null</code>
    124             */
    125            public DependencyNode getRightSibling() throws MaltChainedException;
    126            /**
    127             * Returns the right sibling at the same side of head as the node it self. If not found <code>null</code is returned
    128             *
    129             * @return the right sibling at the same side of head as the node it self. If not found <code>null</code is returned
    130             */
    131            public DependencyNode getSameSideRightSibling() throws MaltChainedException;
    132            /**
    133             * Returns the closest right dependent to the node it self, if not found <code>null</code> is returned.
    134             *
    135             * @return the closest right dependent to the node it self, if not found <code>null</code> is returned.
    136             */
    137            public DependencyNode getClosestRightDependent();
    138            public DependencyNode getRightmostDependent();
    139            public boolean hasRightDependent();
    140            /**
    141             * Returns <i>true</i> if the head edge is projective, otherwise <i>false</i>. Undefined if the node has
    142             * more than one head.
    143             *
    144             * @return <i>true</i> if the head edge is projective, otherwise <i>false</i>.
    145             * @throws MaltChainedException
    146             */
    147            public boolean isProjective() throws MaltChainedException;
    148            /**
    149             * Returns the depth of the node. The root node has the depth 0.
    150             * @return the depth of the node.
    151             * @throws MaltChainedException
    152             */
    153            public int getDependencyNodeDepth() throws MaltChainedException;
    154            public int getRank();
    155            public void setRank(int r);
    156            public DependencyNode findComponent();
    157            public DependencyNode getComponent();
    158            public void setComponent(DependencyNode x);
    159    }