    001    package org.maltparser.core.syntaxgraph;
    002
    003    import java.util.SortedMap;
    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.edge.Edge;
    009    import org.maltparser.core.syntaxgraph.node.DependencyNode;
    010    /**
    011    *
    012    *
    013    * @author Johan Hall
    014    */
    015    public interface DependencyStructure extends TokenStructure, SecEdgeStructure {
    016            public DependencyNode addDependencyNode() throws MaltChainedException;
    017            public DependencyNode addDependencyNode(int index) throws MaltChainedException;
    018            /**
    019             * Returns the dependency node identified by <i>index</i> if it exists, otherwise <i>null</i>.
    020             *
    021             * @param index the index of the dependency node
    022             * @return the dependency node identified by <i>index</i> if it exists, otherwise <i>null</i>.
    023             * @throws MaltChainedException
    024             */
    025            public DependencyNode getDependencyNode(int index) throws MaltChainedException;
    026            public int nDependencyNode();
    027
    028
    029            public int getHighestDependencyNodeIndex();
    030            /**
    031             * Adds an edge from the head to the dependent identified by the indices of the dependency nodes.
    032             *
    033             * @param headIndex the index of the head dependency node
    034             * @param dependentIndex the index of the dependent dependency node
    035             * @return the edge that have been added.
    036             * @throws MaltChainedException
    037             */
    038            public Edge addDependencyEdge(int headIndex, int dependentIndex) throws MaltChainedException;
    039            /**
    040             * Replace the head of the dependent with a new head. The labels are not affected.
    041             *
    042             * @param newHeadIndex the index of the new head dependency node
    043             * @param dependentIndex the index of the dependent dependency node
    044             * @return the edge that have been moved.
    045             * @throws MaltChainedException
    046             */
    047            public Edge moveDependencyEdge(int newHeadIndex, int dependentIndex) throws MaltChainedException;
    048            /**
    049             * Remove an edge from the head to the dependent identified by the indices of the dependency nodes.
    050             * @param headIndex the index of the head dependency node
    051             * @param dependentIndex the index of the dependent dependency node
    052             * @throws MaltChainedException
    053             */
    054            public void removeDependencyEdge(int headIndex, int dependentIndex) throws MaltChainedException;
    055            /**
    056             * Returns the number of edges
    057             *
    058             * @return  the number of edges
    059             */
    060            public int nEdges();
    061            public SortedSet<Edge> getEdges();
    062            /**
    063             * Returns a sorted set of integers {0,s,..n} , where each index i identifies a dependency node. Index 0
    064             * should always be the root dependency node and index s is the first terminal node and index n is the
    065             * last terminal node.
    066             *
    067             * @return a sorted set of integers
    068             */
    069            public SortedSet<Integer> getDependencyIndices();
    070            /**
    071             * Returns the root of the dependency structure.
    072             *
    073             * @return the root of the dependency structure.
    074             */
    075            public DependencyNode getDependencyRoot();
    076            /**
    077             * Returns <i>true</i> if the head edge of the dependency node with <i>index</i> is labeled, otherwise <i>false</i>.
    078             *
    079             * @param index the index of the dependency node
    080             * @return <i>true</i> if the head edge of the dependency node with <i>index</i> is labeled, otherwise <i>false</i>.
    081             * @throws MaltChainedException
    082             */
    083            public boolean hasLabeledDependency(int index) throws MaltChainedException;
    084            /**
    085             * Returns <i>true</i> if all nodes in the dependency structure are connected, otherwise <i>false</i>.
    086             *
    087             * @return <i>true</i> if all nodes in the dependency structure are connected, otherwise <i>false</i>.
    088             */
    089            public boolean isConnected();
    090            /**
    091             * Returns <i>true</i> if all edges in the dependency structure are projective, otherwise <i>false</i>.
    092             *
    093             * @return <i>true</i> if all edges in the dependency structure are projective, otherwise <i>false</i>.
    094             * @throws MaltChainedException
    095             */
    096            public boolean isProjective() throws MaltChainedException;
    097            /**
    098             * Returns <i>true</i> if all dependency nodes have at most one incoming edge, otherwise <i>false</i>.
    099             *
    100             * @return  <i>true</i> if all dependency nodes have at most one incoming edge, otherwise <i>false</i>.
    101             */
    102            public boolean isSingleHeaded();
    103            /**
    104             * Returns <i>true</i> if the dependency structure are a tree (isConnected() && isSingleHeaded()), otherwise <i>false</i>.
    105             *
    106             * @return <i>true</i> if the dependency structure are a tree (isConnected() && isSingleHeaded()), otherwise <i>false</i>.
    107             */
    108            public boolean isTree();
    109            /**
    110             * Returns the number of non-projective edges in the dependency structure.
    111             *
    112             * @return the number of non-projective edges in the dependency structure.
    113             * @throws MaltChainedException
    114             */
    115            public int nNonProjectiveEdges() throws MaltChainedException;
    116            /**
    117             * Links all subtrees to the root of the dependency structure.
    118             *
    119             * @throws MaltChainedException
    120             */
    121            public void linkAllTreesToRoot() throws MaltChainedException;
    122
    123
    124            public LabelSet getDefaultRootEdgeLabels() throws MaltChainedException;
    125            /**
    126             * Returns the default edge label of the root as a string value.
    127             *
    128             * @param table the symbol table that identifies the label type.
    129             * @return the default edge label of the root.
    130             * @throws MaltChainedException
    131             */
    132            public String getDefaultRootEdgeLabelSymbol(SymbolTable table) throws MaltChainedException;
    133            /**
    134             * Returns the default edge label of the root as an integer value.
    135             *
    136             * @param table the symbol table that identifies the label type.
    137             * @return the default edge label of the root as an integer value.
    138             * @throws MaltChainedException
    139             */
    140            public int getDefaultRootEdgeLabelCode(SymbolTable table) throws MaltChainedException;
    141            /**
    142             * Sets the default edge label of the root.
    143             *
    144             * @param table the symbol table that identifies the label type.
    145             * @param defaultRootSymbol the default root edge label
    146             * @throws MaltChainedException
    147             */
    148            public void setDefaultRootEdgeLabel(SymbolTable table, String defaultRootSymbol) throws MaltChainedException;
    149            /**
    150             * Sets the default edge label of the root according to the default root label option
    151             *
    152             * @param rootLabelOption the default root label option
    153             * @param edgeSymbolTables a sorted map that maps the symbol table name to the symbol table object.
    154             * @throws MaltChainedException
    155             */
    156            public void setDefaultRootEdgeLabels(String rootLabelOption, SortedMap<String, SymbolTable> edgeSymbolTables) throws MaltChainedException;
    157    }