//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.maltparser.core.syntaxgraph.DependencyStructure parse(org.maltparser.core.syntaxgraph.DependencyStructure goldDependencyGraph, org.maltparser.core.syntaxgraph.DependencyStructure parseDependencyGraph) throws org.maltparser.core.exception.MaltChainedException
public override IDependencyStructure parse(IDependencyStructure goldDependencyGraph, IDependencyStructure parseDependencyGraph)
{
parserState.clear();
parserState.initialize(parseDependencyGraph);
currentParserConfiguration = parserState.Configuration;
TransitionSystem transitionSystem = parserState.TransitionSystem;
while (!parserState.TerminalState)
{
GuideUserAction action = transitionSystem.getDeterministicAction(parserState.History, currentParserConfiguration);
if (action == null)
{
action = oracleGuide.predict(goldDependencyGraph, currentParserConfiguration);
try
{
classifierGuide.addInstance(featureModel, (GuideDecision)action);
}
catch (System.NullReferenceException e)
{
throw new MaltChainedException("The guide cannot be found. ", e);
}
}
parserState.apply(action);
}
CopyEdges(currentParserConfiguration.DependencyGraph, parseDependencyGraph);
parseDependencyGraph.LinkAllTreesToRoot();
oracleGuide.finalizeSentence(parseDependencyGraph);
return(parseDependencyGraph);
}
//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)
{
CovingtonConfig covingtonConfig = (CovingtonConfig)config;
currentAction.getAction(actionContainers);
Edge e = null;
switch (transActionContainer.ActionCode)
{
case LEFTARC:
e = covingtonConfig.DependencyGraph.AddDependencyEdge(covingtonConfig.RightTarget.Index, covingtonConfig.LeftTarget.Index);
addEdgeLabels(e);
// config.setArcParent(covingtonConfig.getRightTarget());
// config.setArcChild(covingtonConfig.getLeftTarget());
break;
case RIGHTARC:
e = covingtonConfig.DependencyGraph.AddDependencyEdge(covingtonConfig.LeftTarget.Index, covingtonConfig.RightTarget.Index);
addEdgeLabels(e);
// config.setArcParent(covingtonConfig.getLeftTarget());
// config.setArcChild(covingtonConfig.getRightTarget());
break;
default:
// config.setArcParent(null);
// config.setArcChild(null);
break;
}
update(covingtonConfig, transActionContainer.ActionCode);
}
//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)
{
CovingtonConfig covingtonConfig = (CovingtonConfig)config;
DependencyNode leftTarget = covingtonConfig.LeftTarget;
DependencyNode rightTarget = covingtonConfig.RightTarget;
IDependencyStructure dg = covingtonConfig.DependencyGraph;
currentAction.getAction(actionContainers);
int trans = transActionContainer.ActionCode;
if (trans == SHIFT && covingtonConfig.AllowShift == false)
{
return(false);
}
if ((trans == LEFTARC || trans == RIGHTARC) && !ActionContainersLabeled)
{
return(false);
}
if (trans == LEFTARC && leftTarget.Root)
{
return(false);
}
if (trans == LEFTARC && dg.HasLabeledDependency(leftTarget.Index))
{
return(false);
}
if (trans == RIGHTARC && dg.HasLabeledDependency(rightTarget.Index))
{
return(false);
}
return(true);
}
//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: private org.maltparser.parser.history.action.GuideUserAction predict() throws org.maltparser.core.exception.MaltChainedException
private GuideUserAction predict()
{
currentAction.clear();
try
{
manager.DecisionModel.predict(featureModel, currentAction, true);
while (!transitionSystem.permissible(currentAction, config))
{
if (manager.DecisionModel.predictFromKBestList(featureModel, currentAction) == false)
{
GuideUserAction defaultAction = transitionSystem.defaultAction(this, config);
ActionContainer[] actionContainers = ActionContainerArray;
defaultAction.getAction(actionContainers);
currentAction.addAction(actionContainers);
break;
}
}
}
catch (System.NullReferenceException e)
{
throw new MaltChainedException("The guide cannot be found. ", e);
}
return(currentAction);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.maltparser.core.syntaxgraph.DependencyStructure parse(org.maltparser.core.syntaxgraph.DependencyStructure parseDependencyGraph) throws org.maltparser.core.exception.MaltChainedException
public override IDependencyStructure Parse(IDependencyStructure parseDependencyGraph)
{
parserState.clear();
parserState.initialize(parseDependencyGraph);
currentParserConfiguration = parserState.Configuration;
parseCount++;
diagnostics.writeToDiaFile(parseCount + "");
while (!parserState.TerminalState)
{
GuideUserAction action = parserState.TransitionSystem.getDeterministicAction(parserState.History, currentParserConfiguration);
if (action == null)
{
action = predict();
}
else
{
diagnostics.writeToDiaFile(" *");
}
diagnostics.writeToDiaFile(" " + parserState.TransitionSystem.getActionString(action));
parserState.apply(action);
}
CopyEdges(currentParserConfiguration.DependencyGraph, parseDependencyGraph);
CopyDynamicInput(currentParserConfiguration.DependencyGraph, parseDependencyGraph);
parseDependencyGraph.LinkAllTreesToRoot();
diagnostics.writeToDiaFile("\n");
return(parseDependencyGraph);
}
//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 configuration) throws org.maltparser.core.exception.MaltChainedException
public override bool permissible(GuideUserAction currentAction, ParserConfiguration configuration)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final StackConfig config = (StackConfig)configuration;
StackConfig config = (StackConfig)configuration;
currentAction.getAction(actionContainers);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int trans = transActionContainer.getActionCode();
int trans = transActionContainer.ActionCode;
if ((trans == LEFTARC || trans == RIGHTARC) && !ActionContainersLabeled)
{
return(false);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.Stack<org.maltparser.core.syntaxgraph.node.DependencyNode> stack = config.getStack();
Stack <DependencyNode> stack = config.Stack;
if ((trans == LEFTARC || trans == RIGHTARC) && stack.Count < 2)
{
return(false);
}
//JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing:
if (trans == LEFTARC && stack.get(stack.Count - 2).Root)
{
return(false);
}
if (trans == SHIFT && config.Input.Count == 0)
{
return(false);
}
return(true);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public HistoryNode getNewHistoryNode(HistoryNode previousNode, org.maltparser.parser.history.action.GuideUserAction action) throws org.maltparser.core.exception.MaltChainedException
public override HistoryNode getNewHistoryNode(HistoryNode previousNode, GuideUserAction action)
{
HistoryNode node = nodePool.checkOut();
node.Action = action;
node.PreviousNode = previousNode;
list.Add(node);
return(node);
}
//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 configuration) throws org.maltparser.core.exception.MaltChainedException
public override void apply(GuideUserAction currentAction, ParserConfiguration configuration)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final StackConfig config = (StackConfig)configuration;
StackConfig config = (StackConfig)configuration;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.Stack<org.maltparser.core.syntaxgraph.node.DependencyNode> stack = config.getStack();
Stack <DependencyNode> stack = config.Stack;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.Stack<org.maltparser.core.syntaxgraph.node.DependencyNode> input = config.getInput();
Stack <DependencyNode> input = config.Input;
currentAction.getAction(actionContainers);
Edge e = null;
DependencyNode head = null;
DependencyNode dep = null;
switch (transActionContainer.ActionCode)
{
case LEFTARC:
head = stack.Pop();
dep = stack.Pop();
e = config.DependencyStructure.AddDependencyEdge(head.Index, dep.Index);
addEdgeLabels(e);
stack.Push(head);
break;
case RIGHTARC:
dep = stack.Pop();
e = config.DependencyStructure.AddDependencyEdge(stack.Peek().Index, dep.Index);
addEdgeLabels(e);
break;
case SWAP:
dep = stack.Pop();
input.Push(stack.Pop());
stack.Push(dep);
config.lookaheadIncrement();
break;
default:
if (input.Count == 0)
{
stack.Pop();
}
else
{
stack.Push(input.Pop()); // SHIFT
}
config.lookaheadDecrement();
break;
}
}
public HistoryListNode(HistoryNode _previousNode, GuideUserAction _action)
{
previousNode = _previousNode;
action = _action;
if (previousNode != null)
{
position = previousNode.Position + 1;
}
else
{
position = 1;
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public HistoryNode getNewHistoryNode(HistoryNode previousNode, org.maltparser.parser.history.action.GuideUserAction action) throws org.maltparser.core.exception.MaltChainedException
public override HistoryNode getNewHistoryNode(HistoryNode previousNode, GuideUserAction action)
{
HistoryNode node = nodePool.checkOut();
node.Action = action;
if (previousNode == null)
{
node.PreviousNode = root;
}
else
{
node.PreviousNode = previousNode;
}
return(node);
}
//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)
{
TwoPlanarConfig planarConfig = (TwoPlanarConfig)config;
Stack <DependencyNode> activeStack = planarConfig.ActiveStack;
Stack <DependencyNode> inactiveStack = planarConfig.InactiveStack;
Stack <DependencyNode> input = planarConfig.Input;
currentAction.getAction(actionContainers);
Edge e = null;
int actionCode = transActionContainer.ActionCode;
switch (actionCode)
{
case LEFTARC:
e = planarConfig.DependencyStructure.AddDependencyEdge(input.Peek().Index, activeStack.Peek().Index);
addEdgeLabels(e);
break;
case RIGHTARC:
e = planarConfig.DependencyStructure.AddDependencyEdge(activeStack.Peek().Index, input.Peek().Index);
addEdgeLabels(e);
break;
case SWITCH:
planarConfig.switchStacks();
if (planarConfig.reduceAfterSwitch())
{
planarConfig.ActiveStack.Pop();
}
break;
case REDUCE:
activeStack.Pop();
break;
case REDUCEBOTH:
activeStack.Pop();
inactiveStack.Pop();
break;
default: //SHIFT
DependencyNode n = input.Pop();
activeStack.Push(n);
inactiveStack.Push(n);
break;
}
planarConfig.LastAction = actionCode;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.maltparser.core.syntaxgraph.DependencyStructure parse(org.maltparser.core.syntaxgraph.DependencyStructure parseDependencyGraph) throws org.maltparser.core.exception.MaltChainedException
public IDependencyStructure parse(IDependencyStructure parseDependencyGraph)
{
config.clear();
config.DependencyGraph = parseDependencyGraph;
config.initialize();
while (!config.TerminalState)
{
GuideUserAction action = transitionSystem.getDeterministicAction(this, config);
if (action == null)
{
action = predict();
}
transitionSystem.apply(action, config);
}
parseDependencyGraph.LinkAllTreesToRoot();
return(parseDependencyGraph);
}
//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 configuration) throws org.maltparser.core.exception.MaltChainedException
public override GuideUserAction predict(IDependencyStructure gold, ParserConfiguration configuration)
{
StackConfig config = (StackConfig)configuration;
Stack <DependencyNode> stack = config.Stack;
if (!swapArrayActive)
{
createSwapArray(gold);
swapArrayActive = true;
}
GuideUserAction action = null;
if (stack.Count < 2)
{
action = updateActionContainers(NonProjective.SHIFT, null);
}
else
{
//JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing:
DependencyNode left = stack.get(stack.Count - 2);
int leftIndex = left.Index;
//JAVA TO C# CONVERTER TODO TASK: There is no direct .NET Stack equivalent to Java Stack methods based on internal indexing:
int rightIndex = stack.get(stack.Count - 1).Index;
if (swapArray[leftIndex] > swapArray[rightIndex])
{
action = updateActionContainers(NonProjective.SWAP, null);
}
else if (!left.Root && gold.GetTokenNode(leftIndex).Head.Index == rightIndex && nodeComplete(gold, config.DependencyGraph, leftIndex))
{
action = updateActionContainers(NonProjective.LEFTARC, gold.GetTokenNode(leftIndex).HeadEdge.LabelSet);
}
else if (gold.GetTokenNode(rightIndex).Head.Index == leftIndex && nodeComplete(gold, config.DependencyGraph, rightIndex))
{
action = updateActionContainers(NonProjective.RIGHTARC, gold.GetTokenNode(rightIndex).HeadEdge.LabelSet);
}
else
{
action = updateActionContainers(NonProjective.SHIFT, null);
}
}
return(action);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public String getActionString(org.maltparser.parser.history.action.GuideUserAction action) throws org.maltparser.core.exception.MaltChainedException
public virtual string getActionString(GuideUserAction action)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final StringBuilder sb = new StringBuilder();
StringBuilder sb = new StringBuilder();
action.getAction(actionContainers);
Table ttable = transitionTableHandler.getSymbolTable("TRANS");
sb.Append(ttable.getSymbolCodeToString(transActionContainer.ActionCode));
for (int i = 0; i < arcLabelActionContainers.Length; i++)
{
if (arcLabelActionContainers[i].ActionCode != -1)
{
sb.Append("+");
sb.Append(arcLabelActionContainers[i].Table.getSymbolCodeToString(arcLabelActionContainers[i].ActionCode));
}
}
return(sb.ToString());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.maltparser.core.syntaxgraph.DependencyStructure parse(org.maltparser.core.syntaxgraph.DependencyStructure parseDependencyGraph) throws org.maltparser.core.exception.MaltChainedException
public override IDependencyStructure Parse(IDependencyStructure parseDependencyGraph)
{
parserState.clear();
parserState.initialize(parseDependencyGraph);
currentParserConfiguration = parserState.Configuration;
TransitionSystem ts = parserState.TransitionSystem;
while (!parserState.TerminalState)
{
GuideUserAction action = ts.getDeterministicAction(parserState.History, currentParserConfiguration);
if (action == null)
{
action = predict();
}
parserState.apply(action);
}
// copyEdges(currentParserConfiguration.getDependencyGraph(), parseDependencyGraph);
// copyDynamicInput(currentParserConfiguration.getDependencyGraph(), parseDependencyGraph);
parseDependencyGraph.LinkAllTreesToRoot();
return(parseDependencyGraph);
}
//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;
if ((trans == LEFTARC || trans == RIGHTARC) && !ActionContainersLabeled)
{
return(false);
}
DependencyNode stackTop = ((NivreConfig)config).Stack.Peek();
if (!((NivreConfig)config).AllowRoot && stackTop.Root && trans != SHIFT)
{
return(false);
}
if (trans == LEFTARC && stackTop.Root)
{
return(false);
}
return(true);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private org.maltparser.parser.history.action.GuideUserAction predict() throws org.maltparser.core.exception.MaltChainedException
private GuideUserAction predict()
{
GuideUserAction currentAction = parserState.History.EmptyGuideUserAction;
try
{
classifierGuide.predict(featureModel, (GuideDecision)currentAction);
while (!parserState.permissible(currentAction))
{
if (classifierGuide.predictFromKBestList(featureModel, (GuideDecision)currentAction) == false)
{
currentAction = ParserState.TransitionSystem.defaultAction(parserState.History, currentParserConfiguration);
break;
}
}
}
catch (System.NullReferenceException e)
{
throw new MaltChainedException("The guide cannot be found. ", e);
}
return(currentAction);
}
//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)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final NivreConfig nivreConfig = (NivreConfig)config;
NivreConfig nivreConfig = (NivreConfig)config;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.Stack<org.maltparser.core.syntaxgraph.node.DependencyNode> stack = nivreConfig.getStack();
Stack <DependencyNode> stack = nivreConfig.Stack;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.Stack<org.maltparser.core.syntaxgraph.node.DependencyNode> input = nivreConfig.getInput();
Stack <DependencyNode> input = nivreConfig.Input;
currentAction.getAction(actionContainers);
Edge e = null;
switch (transActionContainer.ActionCode)
{
case LEFTARC:
e = nivreConfig.DependencyStructure.AddDependencyEdge(input.Peek().Index, stack.Peek().Index);
addEdgeLabels(e);
stack.Pop();
break;
case RIGHTARC:
e = nivreConfig.DependencyStructure.AddDependencyEdge(stack.Peek().Index, input.Peek().Index);
addEdgeLabels(e);
input.Pop();
if (!stack.Peek().Root)
{
input.Push(stack.Pop());
}
break;
default:
stack.Push(input.Pop()); // SHIFT
break;
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected org.maltparser.parser.history.action.GuideUserAction updateActionContainers(int transition, org.maltparser.core.syntaxgraph.LabelSet arcLabels) throws org.maltparser.core.exception.MaltChainedException
protected internal virtual GuideUserAction updateActionContainers(int transition, LabelSet arcLabels)
{
transActionContainer.Action = transition;
if (arcLabels == null)
{
for (int i = 0; i < arcLabelActionContainers.Length; i++)
{
arcLabelActionContainers[i].Action = -1;
}
}
else
{
for (int i = 0; i < arcLabelActionContainers.Length; i++)
{
arcLabelActionContainers[i].Action = arcLabels.get(arcLabelActionContainers[i].Table).shortValue();
}
}
GuideUserAction oracleAction = history.EmptyGuideUserAction;
oracleAction.addAction(actionContainers);
return(oracleAction);
}
//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);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int trans = transActionContainer.getActionCode();
int trans = transActionContainer.ActionCode;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final NivreConfig nivreConfig = (NivreConfig)config;
NivreConfig nivreConfig = (NivreConfig)config;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.maltparser.core.syntaxgraph.node.DependencyNode stackPeek = nivreConfig.getStack().peek();
DependencyNode stackPeek = nivreConfig.Stack.Peek();
if ((trans == LEFTARC || trans == RIGHTARC) && !ActionContainersLabeled)
{
return(false);
}
if ((trans == LEFTARC || trans == REDUCE) && stackPeek.Root)
{
return(false);
}
if (trans == LEFTARC && stackPeek.hasHead())
{
return(false);
}
if (trans == REDUCE && !stackPeek.hasHead() && !nivreConfig.AllowReduce)
{
return(false);
}
//Added
if (trans == SHIFT && nivreConfig.EnforceTree && nivreConfig.End)
{
return(false);
}
return(true);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected org.maltparser.parser.history.action.GuideUserAction updateActionContainers(org.maltparser.parser.history.GuideUserHistory history, int transition, org.maltparser.core.syntaxgraph.LabelSet arcLabels) throws org.maltparser.core.exception.MaltChainedException
protected internal virtual GuideUserAction updateActionContainers(GuideUserHistory history, int transition, LabelSet arcLabels)
{
transActionContainer.Action = transition;
if (arcLabels == null)
{
for (int i = 0; i < arcLabelActionContainers.Length; i++)
{
arcLabelActionContainers[i].Action = -1;
}
}
else
{
for (int i = 0; i < arcLabelActionContainers.Length; i++)
{
if (arcLabelActionContainers[i] == null)
{
throw new MaltChainedException("arcLabelActionContainer " + i + " is null when doing transition " + transition);
}
int?code = arcLabels.get(arcLabelActionContainers[i].Table);
if (code != null)
{
arcLabelActionContainers[i].Action = code.Value;
}
else
{
arcLabelActionContainers[i].Action = -1;
}
}
}
GuideUserAction oracleAction = history.EmptyGuideUserAction;
oracleAction.addAction(actionContainers);
return(oracleAction);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void clear() throws org.maltparser.core.exception.MaltChainedException
public virtual void clear()
{
previousNode = null;
action = null;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void copyAction(org.maltparser.parser.history.action.GuideUserAction source, org.maltparser.parser.history.action.GuideUserAction target) throws org.maltparser.core.exception.MaltChainedException
public virtual void copyAction(GuideUserAction source, GuideUserAction target)
{
source.getAction(actionContainers);
target.addAction(actionContainers);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public abstract void apply(org.maltparser.parser.history.action.GuideUserAction currentAction, ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException;
public abstract void apply(GuideUserAction currentAction, ParserConfiguration config);
//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;
TwoPlanarConfig planarConfig = (TwoPlanarConfig)config;
DependencyNode activeStackPeek = planarConfig.ActiveStack.Peek();
DependencyNode inactiveStackPeek = planarConfig.InactiveStack.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();
//boolean connectednessConstraintOnReduce = planarConfig.requiresConnectednessCheckOnReduce();
//boolean 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 (activeStackPeek.Root)
{
return(false);
}
//enforce single-head constraint if present
if (activeStackPeek.hasHead() && singleHeadConstraint)
{
return(false);
}
//avoid two links being created from and to the same node
if (activeStackPeek.hasHead() && dg.GetTokenNode(activeStackPeek.Index).Head.Index == inputPeek.Index)
{
return(false);
}
//enforce acyclicity constraint if present
if (acyclicityConstraint && activeStackPeek.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 == activeStackPeek.Index)
{
return(false);
}
//enforce acyclicity constraint if present
if (acyclicityConstraint && activeStackPeek.findComponent().Index == inputPeek.findComponent().Index)
{
return(false);
}
}
if (trans == REDUCE)
{
//do not reduce the dummy root
if (activeStackPeek.Root)
{
return(false);
}
//enforce no-covered-roots constraint if present
if (!activeStackPeek.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 )
* {
* boolean path1 = ( stackPeek.findComponent().getIndex() == inputPeek.findComponent().getIndex() );
* boolean path2;
* if ( planarConfig.getStack().size() < 2 ) path2=false;
* else
* {
* DependencyNode stackPrev = planarConfig.getStack().get(planarConfig.getStack().size()-2);
* path2 = stackPrev.findComponent().getIndex() == stackPeek.findComponent().getIndex();
* }
* return path1 || path2;
* }
*/
}
if (trans == SHIFT)
{
/*
* if ( connectednessConstraintOnShift && planarConfig.getInput().size() == 1 ) //last word
* {
* boolean path = ( planarConfig.getDependencyGraph().getTokenNode(1).findComponent().getIndex() == inputPeek.findComponent().getIndex() ); //require connection to 1st
* return path;
* }
*/
}
if (trans == REDUCEBOTH)
{
//do not reduce the dummy root
if (activeStackPeek.Root || inactiveStackPeek.Root)
{
return(false);
}
//enforce no-covered-roots constraint if present
if ((!activeStackPeek.hasHead() || inactiveStackPeek.hasHead()) && noCoveredRootsConstraint)
{
return(false);
}
//TODO remove this:
//not using this transition at the moment, so
return(false);
}
if (trans == SWITCH)
{
if (planarConfig.reduceAfterSwitch())
{
if (inactiveStackPeek.Root)
{
return(false);
}
//enforce no-covered-roots constraint if present
if (!inactiveStackPeek.hasHead() && noCoveredRootsConstraint)
{
return(false);
}
}
else
{
if (planarConfig.LastAction == SWITCH)
{
return(false);
}
}
}
return(true);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public abstract boolean permissible(org.maltparser.parser.history.action.GuideUserAction currentAction, ParserConfiguration config) throws org.maltparser.core.exception.MaltChainedException;
public abstract bool permissible(GuideUserAction currentAction, ParserConfiguration config);
//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);
}
//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) throws org.maltparser.core.exception.MaltChainedException
public virtual bool permissible(GuideUserAction currentAction)
{
return(transitionSystem.permissible(currentAction, config));
}
//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) throws org.maltparser.core.exception.MaltChainedException
public virtual void apply(GuideUserAction currentAction)
{
transitionSystem.apply(currentAction, config);
}