001    package org.maltparser.parser.algorithm.covington;
002    
003    import org.maltparser.core.exception.MaltChainedException;
004    import org.maltparser.core.syntaxgraph.DependencyStructure;
005    import org.maltparser.core.syntaxgraph.edge.Edge;
006    import org.maltparser.core.syntaxgraph.node.DependencyNode;
007    import org.maltparser.parser.ParserConfiguration;
008    import org.maltparser.parser.TransitionSystem;
009    import org.maltparser.parser.history.GuideUserHistory;
010    import org.maltparser.parser.history.History;
011    import org.maltparser.parser.history.action.ComplexDecisionAction;
012    import org.maltparser.parser.history.action.GuideUserAction;
013    import org.maltparser.parser.transition.TransitionTable;
014    /**
015     * @author Johan Hall
016     *
017     */
018    public class Projective extends TransitionSystem {
019            protected static final int SHIFT = 1;
020            protected static final int NOARC = 2;
021            protected static final int RIGHTARC = 3;
022            protected static final int LEFTARC = 4;
023            
024            
025            public Projective() throws MaltChainedException {
026                    super();
027            }
028            
029            public void apply(GuideUserAction currentAction, ParserConfiguration config) throws MaltChainedException {
030                    CovingtonConfig covingtonConfig = (CovingtonConfig)config;
031                    currentAction.getAction(actionContainers);
032                    
033                    Edge e = null;
034                    switch (transActionContainer.getActionCode()) {
035                    case LEFTARC:
036                            e = covingtonConfig.getDependencyGraph().addDependencyEdge(covingtonConfig.getRightTarget().getIndex(), covingtonConfig.getLeftTarget().getIndex());
037                            addEdgeLabels(e);
038    //                      config.setArcParent(covingtonConfig.getRightTarget());
039    //                      config.setArcChild(covingtonConfig.getLeftTarget());
040                            break;
041                    case RIGHTARC:
042                            e = covingtonConfig.getDependencyGraph().addDependencyEdge(covingtonConfig.getLeftTarget().getIndex(), covingtonConfig.getRightTarget().getIndex());
043                            addEdgeLabels(e);
044    //                      config.setArcParent(covingtonConfig.getLeftTarget());
045    //                      config.setArcChild(covingtonConfig.getRightTarget());
046                            break;
047                    default:
048    //                      config.setArcParent(null);
049    //                      config.setArcChild(null);
050                            break;
051                    }
052                    update(covingtonConfig, transActionContainer.getActionCode());  
053            }
054            
055            private void update(CovingtonConfig covingtonConfig, int trans) throws MaltChainedException {
056                    if (trans == SHIFT || trans == RIGHTARC) {
057                            covingtonConfig.setRight(covingtonConfig.getRight() + 1);
058                            covingtonConfig.setLeft(covingtonConfig.getRight() - 1);
059                    } else {
060                            int leftstop = covingtonConfig.getLeftstop();
061                            int left = covingtonConfig.getLeft();
062                            if (trans == NOARC) {
063                                    DependencyStructure dg = covingtonConfig.getDependencyStructure();
064                                    DependencyNode leftNode = covingtonConfig.getInput().get(covingtonConfig.getLeft());
065                                    if (dg.getTokenNode(leftNode.getIndex()) != null && dg.getTokenNode(leftNode.getIndex()).hasHead()) {
066                                            left = dg.getTokenNode(leftNode.getIndex()).getHead().getIndex();
067                                    } else {
068                                            left = leftstop - 1;
069                                    }
070                            } else {
071                                    DependencyNode rightNode = covingtonConfig.getRightTarget();
072                                    left--;
073                                    DependencyNode leftNode = null;
074                                    while (left >= leftstop) {
075                                            leftNode = covingtonConfig.getInput().get(left);
076                                            if (rightNode.findComponent().getIndex() != leftNode.findComponent().getIndex()) {
077                                                    break;
078                                            }
079                                            left--;
080                                    }
081                            }
082                            
083                            if (left < leftstop) {
084                                    covingtonConfig.setRight(covingtonConfig.getRight() + 1);
085                                    covingtonConfig.setLeft(covingtonConfig.getRight() - 1);
086                            } else {
087                                    covingtonConfig.setLeft(left);
088                            }
089                    }
090            }
091            
092            public GuideUserAction getDeterministicAction(GuideUserHistory history, ParserConfiguration config) throws MaltChainedException {
093                    return null;
094            }
095            
096            protected void addAvailableTransitionToTable(TransitionTable ttable) throws MaltChainedException {
097                    ttable.addTransition(SHIFT, "SH", false, null);
098                    ttable.addTransition(NOARC, "NA", false, null);
099                    ttable.addTransition(RIGHTARC, "RA", true, null);
100                    ttable.addTransition(LEFTARC, "LA", true, null);
101            }
102            
103            protected void initWithDefaultTransitions(GuideUserHistory history) throws MaltChainedException {
104                    GuideUserAction currentAction = new ComplexDecisionAction((History)history);
105                    
106                    transActionContainer.setAction(SHIFT);
107                    transActionContainer.setAction(NOARC);
108                    for (int i = 0; i < arcLabelActionContainers.length; i++) {
109                            arcLabelActionContainers[i].setAction(-1);
110                    }
111                    currentAction.addAction(actionContainers);
112            }
113            
114            public String getName() {
115                    return "covnonproj";
116            }
117            
118            public boolean permissible(GuideUserAction currentAction, ParserConfiguration config) throws MaltChainedException {
119                    CovingtonConfig covingtonConfig = (CovingtonConfig)config;
120                    DependencyNode leftTarget = covingtonConfig.getLeftTarget();
121                    DependencyNode rightTarget = covingtonConfig.getRightTarget();
122                    DependencyStructure dg = covingtonConfig.getDependencyGraph();
123                    currentAction.getAction(actionContainers);
124                    int trans = transActionContainer.getActionCode();
125                    
126                    if (trans == SHIFT && covingtonConfig.isAllowShift() == false) {
127                            return false;
128                    }
129                    if ((trans == LEFTARC || trans == RIGHTARC) && !isActionContainersLabeled()) {
130                            return false;
131                    }
132                    if (trans == LEFTARC && leftTarget.isRoot()) { 
133                            return false;
134                    }
135                    if (trans == LEFTARC && dg.hasLabeledDependency(leftTarget.getIndex())) { 
136                            return false;
137                    }
138                    if (trans == RIGHTARC && dg.hasLabeledDependency(rightTarget.getIndex())) { 
139                            return false;
140                    }
141                    return true;
142            }
143            
144            public GuideUserAction defaultAction(GuideUserHistory history, ParserConfiguration configuration) throws MaltChainedException {
145                    return updateActionContainers(history, Projective.NOARC, null);
146            }
147    }
148