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 }