001    package org.maltparser.core.syntaxgraph.node;
002    
003    import java.util.SortedSet;
004    
005    import org.maltparser.core.exception.MaltChainedException;
006    import org.maltparser.core.syntaxgraph.Element;
007    import org.maltparser.core.syntaxgraph.edge.Edge;
008    
009    public interface ComparableNode extends Element, Comparable<ComparableNode> {
010            /**
011             * Returns the index of the node.
012             * 
013             * @return the index of the node.
014             */
015            public int getIndex();
016            /**
017             * Returns the index of the node (only used internal by compareTo).
018             * 
019             * @return the index of the node (only used internal by compareTo).
020             */
021            public int getCompareToIndex();
022            /**
023             * Returns <i>true</i> if the node is a root node, otherwise <i>false</i>.
024             * 
025             * @return <i>true</i> if the node is a root node, otherwise <i>false</i>.
026             */
027            public boolean isRoot();
028            /**
029             * Returns the left-most proper terminal descendant node (excluding itself). 
030             * 
031             * @return the left-most proper terminal descendant node. 
032             * @throws MaltChainedException
033             */
034            public ComparableNode getLeftmostProperDescendant() throws MaltChainedException;
035            /**
036             * Returns the right-most proper terminal descendant node (excluding itself). 
037             * 
038             * @return the right-most proper terminal descendant node. 
039             * @throws MaltChainedException
040             */
041            public ComparableNode getRightmostProperDescendant() throws MaltChainedException;
042            /**
043             * Returns the index of the left-most proper terminal descendant node (excluding itself). 
044             * 
045             * @return the index of the left-most proper terminal descendant node. 
046             * @throws MaltChainedException
047             */
048            public int getLeftmostProperDescendantIndex() throws MaltChainedException;
049            /**
050             * Returns the index of the right-most proper terminal descendant node (excluding itself). 
051             * 
052             * @return the index of the right-most proper terminal descendant node. 
053             * @throws MaltChainedException
054             */
055            public int getRightmostProperDescendantIndex() throws MaltChainedException;
056            /**
057             * Returns the left-most terminal descendant node. 
058             * 
059             * @return the left-most terminal descendant node. 
060             * @throws MaltChainedException
061             */
062            public ComparableNode getLeftmostDescendant() throws MaltChainedException;
063            /**
064             * Returns the right-most terminal descendant node. 
065             * 
066             * @return the right-most terminal descendant node. 
067             * @throws MaltChainedException
068             */
069            public ComparableNode getRightmostDescendant() throws MaltChainedException;
070            /**
071             * Returns the index of the left-most terminal descendant node. 
072             * 
073             * @return the index of the left-most terminal descendant node. 
074             * @throws MaltChainedException
075             */
076            public int getLeftmostDescendantIndex() throws MaltChainedException;
077            /**
078             * Returns the index of the right-most terminal descendant node. 
079             * 
080             * @return the index of the right-most terminal descendant node. 
081             * @throws MaltChainedException
082             */
083            public int getRightmostDescendantIndex() throws MaltChainedException;
084            /**
085             * Returns the in degree of the node (number of incoming edges of all types of edges).
086             * 
087             * @return the in degree of the node (number of incoming edges of all types of edges).
088             */
089            public int getInDegree();
090            /**
091             * Returns the out degree of the node (number of outgoing edges of all types of edges).
092             * 
093             * @return the out degree of the node (number of outgoing edges of all types of edges).
094             */
095            public int getOutDegree();
096            /**
097             * Returns a sorted set of incoming secondary edges.
098             * 
099             * @return a sorted set of incoming secondary edges.
100             */
101            public SortedSet<Edge> getIncomingSecondaryEdges();
102            /**
103             * Returns a sorted set of outgoing secondary edges.
104             * 
105             * @return a sorted set of outgoing secondary edges.
106             */
107            public SortedSet<Edge> getOutgoingSecondaryEdges();
108    }