//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void apply(org.maltparser.parser.history.action.GuideUserAction currentAction, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override void apply(GuideUserAction currentAction, ParserConfiguration config) { PlanarConfig planarConfig = (PlanarConfig)config; Stack <DependencyNode> stack = planarConfig.Stack; Stack <DependencyNode> input = planarConfig.Input; currentAction.getAction(actionContainers); Edge e = null; switch (transActionContainer.ActionCode) { case LEFTARC: e = planarConfig.DependencyStructure.AddDependencyEdge(input.Peek().Index, stack.Peek().Index); addEdgeLabels(e); break; case RIGHTARC: e = planarConfig.DependencyStructure.AddDependencyEdge(stack.Peek().Index, input.Peek().Index); addEdgeLabels(e); break; case REDUCE: stack.Pop(); break; default: //SHIFT stack.Push(input.Pop()); break; } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public org.maltparser.parser.history.action.GuideUserAction predict(org.maltparser.core.syntaxgraph.DependencyStructure gold, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override GuideUserAction predict(IDependencyStructure gold, ParserConfiguration config) { PlanarConfig planarConfig = (PlanarConfig)config; IDependencyStructure dg = planarConfig.DependencyGraph; DependencyNode stackPeek = planarConfig.Stack.Peek(); int stackPeekIndex = stackPeek.Index; int inputPeekIndex = planarConfig.Input.Peek().Index; if (!stackPeek.Root && gold.GetTokenNode(stackPeekIndex).Head.Index == inputPeekIndex && !checkIfArcExists(dg, inputPeekIndex, stackPeekIndex)) { return(updateActionContainers(Planar.LEFTARC, gold.GetTokenNode(stackPeekIndex).HeadEdge.LabelSet)); } else if (gold.GetTokenNode(inputPeekIndex).Head.Index == stackPeekIndex && !checkIfArcExists(dg, stackPeekIndex, inputPeekIndex)) { return(updateActionContainers(Planar.RIGHTARC, gold.GetTokenNode(inputPeekIndex).HeadEdge.LabelSet)); } else if (gold.GetTokenNode(inputPeekIndex).hasLeftDependent() && gold.GetTokenNode(inputPeekIndex).LeftmostDependent.Index < stackPeekIndex) { return(updateActionContainers(Planar.REDUCE, null)); } else if (gold.GetTokenNode(inputPeekIndex).Head.Index < stackPeekIndex && (!gold.GetTokenNode(inputPeekIndex).Head.Root || planarConfig.getRootHandling() == PlanarConfig.NORMAL)) { return(updateActionContainers(Planar.REDUCE, null)); } else { return(updateActionContainers(Planar.SHIFT, null)); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void initialize(org.maltparser.parser.ParserConfiguration parserConfiguration) throws org.maltparser.core.exception.MaltChainedException public virtual void initialize(ParserConfiguration parserConfiguration) { if (parserConfiguration != null) { PlanarConfig planarConfig = (PlanarConfig)parserConfiguration; Stack <DependencyNode> sourceStack = planarConfig.Stack; Stack <DependencyNode> sourceInput = planarConfig.Input; DependencyGraph = planarConfig.DependencyGraph; for (int i = 0, n = sourceStack.Count; i < n; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: stack.Push(dependencyGraph.GetDependencyNode(sourceStack.get(i).Index)); } for (int i = 0, n = sourceInput.Count; i < n; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: input.Push(dependencyGraph.GetDependencyNode(sourceInput.get(i).Index)); } } else { stack.Push(dependencyGraph.DependencyRoot); for (int i = dependencyGraph.HighestTokenIndex; i > 0; i--) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode node = dependencyGraph.getDependencyNode(i); DependencyNode node = dependencyGraph.GetDependencyNode(i); if (node != null && !node.hasHead()) { input.Push(node); } } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public org.maltparser.parser.history.action.GuideUserAction getDeterministicAction(org.maltparser.parser.history.GuideUserHistory history, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override GuideUserAction getDeterministicAction(GuideUserHistory history, ParserConfiguration config) { PlanarConfig planarConfig = (PlanarConfig)config; if (planarConfig.getRootHandling() != PlanarConfig.NORMAL && planarConfig.Stack.Peek().Root) { return(updateActionContainers(history, SHIFT, null)); } return(null); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void update(PlanarConfig config) throws org.maltparser.core.exception.MaltChainedException private void update(PlanarConfig config) { if (subFunction == PlanarSubFunction.STACK) { address.Address = config.getStackNode(index); } else if (subFunction == PlanarSubFunction.INPUT) { address.Address = config.getInputNode(index); } else { address.Address = null; } }
public override bool Equals(object obj) { if (this == obj) { return(true); } if (obj == null) { return(false); } if (GetType() != obj.GetType()) { return(false); } PlanarConfig that = (PlanarConfig)obj; if (stack.Count != that.Stack.Count) { return(false); } if (input.Count != that.Input.Count) { return(false); } if (dependencyGraph.NEdges() != that.DependencyGraph.NEdges()) { return(false); } for (int i = 0; i < stack.Count; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: if (stack.get(i).Index != that.Stack.get(i).Index) { return(false); } } for (int i = 0; i < input.Count; i++) { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: if (input.get(i).Index != that.Input.get(i).Index) { return(false); } } return(dependencyGraph.Edges.Equals(that.DependencyGraph.Edges)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public boolean permissible(org.maltparser.parser.history.action.GuideUserAction currentAction, org.maltparser.parser.ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException public override bool permissible(GuideUserAction currentAction, ParserConfiguration config) { currentAction.getAction(actionContainers); int trans = transActionContainer.ActionCode; PlanarConfig planarConfig = (PlanarConfig)config; DependencyNode stackPeek = planarConfig.Stack.Peek(); DependencyNode inputPeek = planarConfig.Input.Peek(); IDependencyStructure dg = planarConfig.DependencyGraph; //int rootHandling = planarConfig.getRootHandling(); bool singleHeadConstraint = planarConfig.requiresSingleHead(); bool noCoveredRootsConstraint = planarConfig.requiresNoCoveredRoots(); bool acyclicityConstraint = planarConfig.requiresAcyclicity(); bool connectednessConstraintOnReduce = planarConfig.requiresConnectednessCheckOnReduce(); bool connectednessConstraintOnShift = planarConfig.requiresConnectednessCheckOnShift(); if ((trans == LEFTARC || trans == RIGHTARC) && !ActionContainersLabeled) { return(false); } //if ((trans == LEFTARC || trans == REDUCE) && stackPeek.isRoot()) { // return false; //} if (trans == LEFTARC) { //avoid making root child of something if (stackPeek.Root) { return(false); } //enforce single-head constraint if present if (stackPeek.hasHead() && singleHeadConstraint) { return(false); } //avoid two links being created from and to the same node if (stackPeek.hasHead() && dg.GetTokenNode(stackPeek.Index).Head.Index == inputPeek.Index) { return(false); } //enforce acyclicity constraint if present if (acyclicityConstraint && stackPeek.findComponent().Index == inputPeek.findComponent().Index) { return(false); } } if (trans == RIGHTARC) { //enforce single-head constraint if present if (inputPeek.hasHead() && singleHeadConstraint) { return(false); } //avoid two links being created from and to the same node if (inputPeek.hasHead() && dg.GetTokenNode(inputPeek.Index).Head.Index == stackPeek.Index) { return(false); } //enforce acyclicity constraint if present if (acyclicityConstraint && stackPeek.findComponent().Index == inputPeek.findComponent().Index) { return(false); } } if (trans == REDUCE) { //do not reduce the dummy root if (stackPeek.Root) { return(false); } //enforce no-covered-roots constraint if present if (!stackPeek.hasHead() && noCoveredRootsConstraint) { return(false); } //TODO does this line still make sense? (from Nivre arc-eager) //if ( !stackPeek.hasHead() && rootHandling == PlanarConfig.STRICT ) // return false; //enforce connectedness constraint if present if (connectednessConstraintOnReduce) { bool path1 = (stackPeek.findComponent().Index == inputPeek.findComponent().Index); bool path2; if (planarConfig.Stack.Count < 2) { path2 = false; } else { //JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing: DependencyNode stackPrev = planarConfig.Stack.get(planarConfig.Stack.Count - 2); path2 = stackPrev.findComponent().Index == stackPeek.findComponent().Index; } return(path1 || path2); } } if (trans == SHIFT) { if (connectednessConstraintOnShift && planarConfig.Input.Count == 1) //last word { bool path = (planarConfig.DependencyGraph.GetTokenNode(1).findComponent().Index == inputPeek.findComponent().Index); //require connection to 1st return(path); } } return(true); }