    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    }