//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void initOutput(String nullValueStategy) throws org.maltparser.core.exception.MaltChainedException
public virtual void initOutput(string nullValueStategy)
{
ConfigurationDir configDir = (ConfigurationDir)flowChartinstance.getFlowChartRegistry(typeof(ConfigurationDir), idName);
DataFormatManager dataFormatManager = configDir.DataFormatManager;
SymbolTableHandler symbolTables = configDir.SymbolTables;
if (configDir.sizeDataFormatInstance() == 0 || dataFormatManager.InputDataFormatSpec != dataFormatManager.OutputDataFormatSpec)
{
outputDataFormatInstance = dataFormatManager.OutputDataFormatSpec.createDataFormatInstance(symbolTables, nullValueStategy);
configDir.addDataFormatInstance(dataFormatManager.InputDataFormatSpec.DataFormatName, outputDataFormatInstance);
}
else
{
outputDataFormatInstance = configDir.getDataFormatInstance(dataFormatManager.InputDataFormatSpec.DataFormatName); //dataFormatInstances.get(dataFormatManager.getInputDataFormatSpec().getDataFormatName());
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public LWSingleMalt(int containerIndex, org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, McoModel _mcoModel, org.maltparser.core.propagation.PropagationManager _propagationManager, org.maltparser.core.feature.FeatureModelManager _featureModelManager) throws org.maltparser.core.exception.MaltChainedException
public LWSingleMalt(int containerIndex, DataFormatInstance dataFormatInstance, McoModel _mcoModel, PropagationManager _propagationManager, FeatureModelManager _featureModelManager)
{
optionContainerIndex = containerIndex;
mcoModel = _mcoModel;
this.dataFormatInstance = dataFormatInstance;
propagationManager = _propagationManager;
featureModelManager = _featureModelManager;
parserFactory = makeParserFactory();
decisionSettings = getOptionValue("guide", "decision_settings").ToString().Trim();
kBestSize = ((int?)getOptionValue("guide", "kbest")).Value;
classitem_separator = getOptionValue("guide", "classitem_separator").ToString().Trim();
featureModelURL = getConfigFileEntryURL(getOptionValue("guide", "features").ToString().Trim());
dataSplitColumn = getOptionValue("guide", "data_split_column").ToString().Trim();
dataSplitStructure = getOptionValue("guide", "data_split_structure").ToString().Trim();
excludeNullValues = getOptionValue("singlemalt", "null_value").ToString().Equals("none", StringComparison.OrdinalIgnoreCase);
decisionModel = new LWDecisionModel(mcoModel, excludeNullValues, getOptionValueString("guide", "learner"));
}
/// <summary>
/// Creates a propagation object based on the propagation specification
/// </summary>
/// <param name="spec"> a propagation specification </param>
/// <param name="dataFormatInstance"> a data format instance </param>
/// <exception cref="MaltChainedException"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public Propagation(org.maltparser.core.propagation.spec.PropagationSpec spec, org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler tableHandler) throws org.maltparser.core.exception.MaltChainedException
public Propagation(PropagationSpec spec, DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler)
{
ColumnDescription fromColumn = dataFormatInstance.getColumnDescriptionByName(spec.From);
if (fromColumn == null)
{
throw new PropagationException("The symbol table '" + spec.From + " does not exists.");
}
fromTable = tableHandler.getSymbolTable(spec.From);
ColumnDescription toColumn = dataFormatInstance.getColumnDescriptionByName(spec.To);
if (toColumn == null)
{
toColumn = dataFormatInstance.addInternalColumnDescription(tableHandler, spec.To, fromColumn);
toTable = tableHandler.getSymbolTable(spec.To);
}
forSet = new SortedSet <string>();
if (!ReferenceEquals(spec.For, null) && spec.For.Length > 0)
{
string[] items = spec.For.Split("\\|", true);
foreach (string item in items)
{
forSet.Add(item);
}
}
overSet = new SortedSet <string>();
if (!ReferenceEquals(spec.Over, null) && spec.Over.Length > 0)
{
string[] items = spec.Over.Split("\\|", true);
foreach (string item in items)
{
overSet.Add(item);
}
}
// ColumnDescription deprelColumn = dataFormatInstance.getColumnDescriptionByName("DEPREL");
deprelTable = tableHandler.getSymbolTable("DEPREL");
symbolSeparator = Pattern.compile("\\|");
}
public LosslessMapping(DataFormatInstance dependencyDataFormatInstance, DataFormatInstance phraseStructuretDataFormatInstance, SymbolTableHandler symbolTableHandler)
{
this.symbolTableHandler = symbolTableHandler;
DependencyDataFormatInstance = dependencyDataFormatInstance;
PhraseStructuretDataFormatInstance = phraseStructuretDataFormatInstance;
deprel = new StringBuilder();
headrel = new StringBuilder();
phrase = new StringBuilder();
if (phraseStructuretDataFormatInstance.PhraseStructureEdgeLabelColumnDescriptionSet.Count == 1)
{
foreach (ColumnDescription column in phraseStructuretDataFormatInstance.PhraseStructureEdgeLabelColumnDescriptionSet)
{
EDGELABEL = column.Name;
}
}
clear();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static String[] toStringArray(org.maltparser.core.syntaxgraph.DependencyGraph graph, org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler symbolTables) throws org.maltparser.core.exception.MaltChainedException
public static string[] toStringArray(DependencyGraph graph, DataFormatInstance dataFormatInstance, SymbolTableHandler symbolTables)
{
string[] tokens = new string[graph.NTokenNode()];
StringBuilder sb = new StringBuilder();
IEnumerator <ColumnDescription> columns = dataFormatInstance.GetEnumerator();
foreach (int?index in graph.TokenIndices)
{
sb.Length = 0;
if (index <= tokens.Length)
{
ColumnDescription column = null;
TokenNode node = graph.GetTokenNode(index.Value);
while (columns.MoveNext())
{
column = columns.Current;
if (column.Category == ColumnDescription.INPUT)
{
if (!column.Name.Equals("ID"))
{
if (node.hasLabel(symbolTables.getSymbolTable(column.Name)) && node.getLabelSymbol(symbolTables.getSymbolTable(column.Name)).Length > 0)
{
sb.Append(node.getLabelSymbol(symbolTables.getSymbolTable(column.Name)));
}
else
{
sb.Append('_');
}
}
else
{
sb.Append(index.ToString());
}
sb.Append('\t');
}
}
sb.Length = sb.Length - 1;
tokens[index - 1] = sb.ToString();
columns = dataFormatInstance.GetEnumerator();
}
}
return(tokens);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public int preprocess(int signal) throws org.maltparser.core.exception.MaltChainedException
public override int preprocess(int signal)
{
if (taskName.Equals("init"))
{
ConfigurationDir configDir = (ConfigurationDir)flowChartinstance.getFlowChartRegistry(typeof(ConfigurationDir), idName);
// SymbolTableHandler symbolTables = configDir.getSymbolTables();
DataFormatInstance dataFormatInstance = configDir.InputDataFormatInstance;
marking_strategy = OptionManager.instance().getOptionValue(OptionContainerIndex, "pproj", "marking_strategy").ToString().Trim();
covered_root = OptionManager.instance().getOptionValue(OptionContainerIndex, "pproj", "covered_root").ToString().Trim();
lifting_order = OptionManager.instance().getOptionValue(OptionContainerIndex, "pproj", "lifting_order").ToString().Trim();
if (!marking_strategy.Equals("none", StringComparison.OrdinalIgnoreCase) || !covered_root.Equals("none", StringComparison.OrdinalIgnoreCase))
{
pproj.initialize(marking_strategy, covered_root, lifting_order, SystemLogger.logger(), dataFormatInstance, configDir.SymbolTables);
}
if (!marking_strategy.Equals("none", StringComparison.OrdinalIgnoreCase) || !covered_root.Equals("none", StringComparison.OrdinalIgnoreCase))
{
pprojActive = true;
}
}
return(signal);
}
/// <summary>
/// Initialize a parser model that later can by used to parse sentences. MaltParser is controlled by a commandLine string, please see the documentation of MaltParser to see all available options.
/// </summary>
/// <param name="commandLine"> a commandLine string that controls the MaltParser </param>
/// <exception cref="MaltChainedException"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void initializeParserModel(String commandLine) throws org.maltparser.core.exception.MaltChainedException
public virtual void initializeParserModel(string commandLine)
{
if (optionContainer == -1)
{
throw new MaltChainedException("MaltParserService has been initialized as an option free initialization and therefore no parser model can be initialized.");
}
OptionManager.instance().parseCommandLine(commandLine, optionContainer);
// Creates an engine
engine = new Engine();
// Initialize the engine with option container and gets a flow chart instance
flowChartInstance = engine.initialize(optionContainer);
// Runs the preprocess chart items of the "parse" flow chart
if (flowChartInstance.hasPreProcessChartItems())
{
flowChartInstance.preprocess();
}
singleMalt = (SingleMalt)flowChartInstance.getFlowChartRegistry(typeof(SingleMalt), "singlemalt");
singleMalt.ConfigurationDir.initDataFormat();
dataFormatInstance = singleMalt.ConfigurationDir.DataFormatManager.InputDataFormatSpec.createDataFormatInstance(singleMalt.SymbolTables, OptionManager.instance().getOptionValueString(optionContainer, "singlemalt", "null_value"));
initialized = true;
}
/// <summary>
/// This constructor can only be used by ConcurrentMaltParserService
/// </summary>
/// <param name="_optionContainer"> a option container index </param>
/// <param name="_mcoURL"> a URL to a valid MaltParser model file. </param>
/// <exception cref="MaltChainedException"> </exception>
internal ConcurrentMaltParserModel(int _optionContainer, Url _mcoURL)
{
var optionContainer = _optionContainer;
McoModel mcoModel = new McoModel(_mcoURL);
string inputFormatName = OptionManager.instance().getOptionValue(optionContainer, "input", "format").ToString().Trim();
Url inputFormatURL = null;
try
{
inputFormatURL = mcoModel.GetMcoEntryUrl(inputFormatName);
}
catch (IOException e)
{
throw new MaltChainedException("Couldn't read file " + inputFormatName + " from mco-file ", e);
}
DataFormatManager dataFormatManager = new DataFormatManager(inputFormatURL, inputFormatURL);
parentSymbolTableHandler = new HashSymbolTableHandler();
DataFormatInstance dataFormatInstance = dataFormatManager.InputDataFormatSpec.createDataFormatInstance(parentSymbolTableHandler, OptionManager.instance().getOptionValueString(optionContainer, "singlemalt", "null_value"));
try
{
parentSymbolTableHandler.load(mcoModel.GetInputStreamReader("symboltables.sym", "UTF-8"));
}
catch (IOException e)
{
throw new MaltChainedException("Couldn't read file symboltables.sym from mco-file ", e);
}
defaultRootLabel = OptionManager.instance().getOptionValue(optionContainer, "graph", "root_label").ToString().Trim();
markingStrategy = LWDeprojectivizer.getMarkingStrategyInt(OptionManager.instance().getOptionValue(optionContainer, "pproj", "marking_strategy").ToString().Trim());
coveredRoot = !OptionManager.instance().getOptionValue(optionContainer, "pproj", "covered_root").ToString().Trim().Equals("none", StringComparison.OrdinalIgnoreCase);
FeatureModelManager featureModelManager = loadFeatureModelManager(optionContainer, mcoModel);
singleMalt = new LWSingleMalt(optionContainer, dataFormatInstance, mcoModel, null, featureModelManager);
concurrentDataFormat = DataFormat.ParseDataFormatXmLfile(inputFormatURL);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public InputTableFeature(org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler tableHandler) throws org.maltparser.core.exception.MaltChainedException
public InputTableFeature(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler) : base(tableHandler)
{
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public int preprocess(int signal) throws org.maltparser.core.exception.MaltChainedException
public override int preprocess(int signal)
{
if (taskName.Equals("init"))
{
if (modeName.Equals("learn") || modeName.Equals("parse"))
{
OptionManager.instance().overloadOptionValue(OptionContainerIndex, "singlemalt", "mode", modeName);
ConfigurationDir configDir = (ConfigurationDir)flowChartinstance.getFlowChartRegistry(typeof(ConfigurationDir), idName);
DataFormatManager dataFormatManager = configDir.DataFormatManager;
if (modeName.Equals("learn"))
{
DataFormatInstance dataFormatInstance = null;
if (dataFormatManager.InputDataFormatSpec.DataStructure == DataStructure.PHRASE)
{
ISet <Dependency> deps = dataFormatManager.InputDataFormatSpec.Dependencies;
string nullValueStrategy = OptionManager.instance().getOptionValue(OptionContainerIndex, "singlemalt", "null_value").ToString();
foreach (Dependency dep in dataFormatManager.InputDataFormatSpec.Dependencies)
{
dataFormatInstance = dataFormatManager.getDataFormatSpec(dep.DependentOn).createDataFormatInstance(configDir.SymbolTables, nullValueStrategy);
configDir.addDataFormatInstance(dataFormatManager.OutputDataFormatSpec.DataFormatName, dataFormatInstance);
}
string decisionSettings = OptionManager.instance().getOptionValue(OptionContainerIndex, "guide", "decision_settings").ToString().Trim();
StringBuilder newDecisionSettings = new StringBuilder();
if (!Pattern.matches(".*A\\.HEADREL.*", decisionSettings))
{
newDecisionSettings.Append("+A.HEADREL");
}
if (!Pattern.matches(".*A\\.PHRASE.*", decisionSettings))
{
newDecisionSettings.Append("+A.PHRASE");
}
if (!Pattern.matches(".*A\\.ATTACH.*", decisionSettings))
{
newDecisionSettings.Append("+A.ATTACH");
}
if (newDecisionSettings.Length > 0)
{
OptionManager.instance().overloadOptionValue(OptionContainerIndex, "guide", "decision_settings", decisionSettings + newDecisionSettings.ToString());
}
}
else
{
dataFormatInstance = configDir.getDataFormatInstance(dataFormatManager.InputDataFormatSpec.DataFormatName);
}
singleMalt.initialize(OptionContainerIndex, dataFormatInstance, configDir.SymbolTables, configDir, SingleMalt.LEARN);
}
else if (modeName.Equals("parse"))
{
singleMalt.initialize(OptionContainerIndex, configDir.getDataFormatInstance(dataFormatManager.InputDataFormatSpec.DataFormatName), configDir.SymbolTables, configDir, SingleMalt.PARSE);
}
else
{
return(TERMINATE);
}
}
else
{
return(TERMINATE);
}
}
return(signal);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public PrefixFeature(org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler tableHandler) throws org.maltparser.core.exception.MaltChainedException
public PrefixFeature(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler)
{
this.dataFormatInstance = dataFormatInstance;
this.tableHandler = tableHandler;
multipleFeatureValue = new MultipleFeatureValue(this);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public InputColumnFeature(org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler tableHandler) throws org.maltparser.core.exception.MaltChainedException
public InputColumnFeature(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler) : base()
{
this.dataFormatInstance = dataFormatInstance;
this.tableHandler = tableHandler;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public int preprocess(int signal) throws org.maltparser.core.exception.MaltChainedException
public override int preprocess(int signal)
{
if (taskName.Equals("create"))
{
bool phrase = false;
bool dependency = false;
ConfigurationDir configDir = (ConfigurationDir)flowChartinstance.getFlowChartRegistry(typeof(ConfigurationDir), idName);
DataFormatInstance dataFormatInstance = null;
DataFormatManager dataFormatManager = configDir.DataFormatManager;
SymbolTableHandler symbolTables = configDir.SymbolTables;
foreach (string key in configDir.DataFormatInstanceKeys)
{
DataFormatInstance dfi = configDir.getDataFormatInstance(key);
if (dfi.DataFormarSpec.DataStructure == DataStructure.PHRASE)
{
phrase = true;
}
if (dfi.DataFormarSpec.DataStructure == DataStructure.DEPENDENCY)
{
dependency = true;
dataFormatInstance = dfi;
}
}
if (dependency == false && OptionManager.instance().getOptionValue(OptionContainerIndex, "config", "flowchart").ToString().Equals("learn"))
{
dependency = true;
HashSet <Dependency> deps = dataFormatManager.InputDataFormatSpec.Dependencies;
string nullValueStategy = OptionManager.instance().getOptionValue(OptionContainerIndex, "singlemalt", "null_value").ToString();
foreach (Dependency dep in deps)
{
dataFormatInstance = dataFormatManager.getDataFormatSpec(dep.DependentOn).createDataFormatInstance(symbolTables, nullValueStategy);
configDir.addDataFormatInstance(dataFormatManager.OutputDataFormatSpec.DataFormatName, dataFormatInstance);
}
}
if (dependency == true && phrase == false)
{
graph = new DependencyGraph(symbolTables);
flowChartinstance.addFlowChartRegistry(typeof(IDependencyStructure), structureName, graph);
}
else if (dependency == true && phrase == true)
{
graph = new MappablePhraseStructureGraph(symbolTables);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.maltparser.core.io.dataformat.DataFormatInstance inFormat = configDir.getDataFormatInstance(dataFormatManager.getInputDataFormatSpec().getDataFormatName());
DataFormatInstance inFormat = configDir.getDataFormatInstance(dataFormatManager.InputDataFormatSpec.DataFormatName);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.maltparser.core.io.dataformat.DataFormatInstance outFormat = configDir.getDataFormatInstance(dataFormatManager.getOutputDataFormatSpec().getDataFormatName());
DataFormatInstance outFormat = configDir.getDataFormatInstance(dataFormatManager.OutputDataFormatSpec.DataFormatName);
if (inFormat != null && outFormat != null)
{
LosslessMapping mapping = null;
if (inFormat.DataFormarSpec.DataStructure == DataStructure.DEPENDENCY)
{
mapping = new LosslessMapping(inFormat, outFormat, symbolTables);
}
else
{
mapping = new LosslessMapping(outFormat, inFormat, symbolTables);
}
if (inFormat.DataFormarSpec.DataStructure == DataStructure.PHRASE)
{
mapping.setHeadRules(OptionManager.instance().getOptionValue(OptionContainerIndex, "graph", "head_rules").ToString());
}
((MappablePhraseStructureGraph)graph).Mapping = mapping;
}
else
{
throw new FlowException("Couldn't determine the input and output data format. ");
}
flowChartinstance.addFlowChartRegistry(typeof(IDependencyStructure), structureName, graph);
flowChartinstance.addFlowChartRegistry(typeof(PhraseStructure), structureName, graph);
}
else if (dependency == false && phrase == true)
{
graph = new PhraseStructureGraph(symbolTables);
flowChartinstance.addFlowChartRegistry(typeof(PhraseStructure), structureName, graph);
}
else
{
graph = new Sentence(symbolTables);
}
if (dataFormatInstance != null)
{
((IDependencyStructure)graph).SetDefaultRootEdgeLabels(OptionManager.instance().getOptionValue(OptionContainerIndex, "graph", "root_label").ToString(), dataFormatInstance.getDependencyEdgeLabelSymbolTables(symbolTables));
}
flowChartinstance.addFlowChartRegistry(typeof(ITokenStructure), structureName, graph);
}
return(signal);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public InputArcFeature(org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler tableHandler) throws org.maltparser.core.exception.MaltChainedException
public InputArcFeature(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler)
{
this.dataFormatInstance = dataFormatInstance;
this.tableHandler = tableHandler;
featureValue = new SingleFeatureValue(this);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void createPropagations(org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler tableHandler) throws org.maltparser.core.exception.MaltChainedException
public virtual void createPropagations(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler)
{
propagations = new Propagations(propagationSpecs, dataFormatInstance, tableHandler);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void initialize(String markingStrategyString, String coveredRoot, String liftingOrder, org.apache.log4j.Logger configLogger, org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler symbolTables) throws org.maltparser.core.exception.MaltChainedException
public virtual void initialize(string markingStrategyString, string coveredRoot, string liftingOrder, Logger configLogger, DataFormatInstance dataFormatInstance, SymbolTableHandler symbolTables)
{
nodeLifted = new List <bool>();
nodeTrace = new List <List <DependencyNode> >();
headDeprel = new List <DependencyNode>();
nodePath = new List <bool>();
isCoveredRoot_Renamed = new List <bool>();
nodeRelationLength = new List <int>();
synacticHeadDeprel = new List <string>();
this.configLogger = configLogger;
if (markingStrategyString.Equals("none", StringComparison.OrdinalIgnoreCase))
{
markingStrategy = PseudoProjectiveEncoding.NONE;
}
else if (markingStrategyString.Equals("baseline", StringComparison.OrdinalIgnoreCase))
{
markingStrategy = PseudoProjectiveEncoding.BASELINE;
}
else if (markingStrategyString.Equals("head", StringComparison.OrdinalIgnoreCase))
{
markingStrategy = PseudoProjectiveEncoding.HEAD;
}
else if (markingStrategyString.Equals("path", StringComparison.OrdinalIgnoreCase))
{
markingStrategy = PseudoProjectiveEncoding.PATH;
}
else if (markingStrategyString.Equals("head+path", StringComparison.OrdinalIgnoreCase))
{
markingStrategy = PseudoProjectiveEncoding.HEADPATH;
}
else if (markingStrategyString.Equals("trace", StringComparison.OrdinalIgnoreCase))
{
markingStrategy = PseudoProjectiveEncoding.TRACE;
}
deprelColumn = dataFormatInstance.getColumnDescriptionByName("DEPREL");
deprelSymbolTable = symbolTables.getSymbolTable(deprelColumn.Name);
if (markingStrategy == PseudoProjectiveEncoding.HEAD || markingStrategy == PseudoProjectiveEncoding.PATH || markingStrategy == PseudoProjectiveEncoding.HEADPATH)
{
ppliftedColumn = dataFormatInstance.addInternalColumnDescription(symbolTables, "PPLIFTED", "DEPENDENCY_EDGE_LABEL", "BOOLEAN", "", deprelColumn.NullValueStrategy);
ppliftedSymbolTable = symbolTables.getSymbolTable(ppliftedColumn.Name);
if (markingStrategy == PseudoProjectiveEncoding.PATH)
{
ppliftedSymbolTable.addSymbol("#true#");
ppliftedSymbolTable.addSymbol("#false#");
}
else
{
ppliftedSymbolTable.addSymbol("#false#");
}
}
if (markingStrategy == PseudoProjectiveEncoding.PATH || markingStrategy == PseudoProjectiveEncoding.HEADPATH)
{
pppathColumn = dataFormatInstance.addInternalColumnDescription(symbolTables, "PPPATH", "DEPENDENCY_EDGE_LABEL", "BOOLEAN", "", deprelColumn.NullValueStrategy);
pppathSymbolTable = symbolTables.getSymbolTable(pppathColumn.Name);
pppathSymbolTable.addSymbol("#true#");
pppathSymbolTable.addSymbol("#false#");
}
if (coveredRoot.Equals("none", StringComparison.OrdinalIgnoreCase))
{
rootAttachment = CoveredRootAttachment.NONE;
}
else if (coveredRoot.Equals("ignore", StringComparison.OrdinalIgnoreCase))
{
rootAttachment = CoveredRootAttachment.IGNORE;
}
else if (coveredRoot.Equals("left", StringComparison.OrdinalIgnoreCase))
{
rootAttachment = CoveredRootAttachment.LEFT;
}
else if (coveredRoot.Equals("right", StringComparison.OrdinalIgnoreCase))
{
rootAttachment = CoveredRootAttachment.RIGHT;
}
else if (coveredRoot.Equals("head", StringComparison.OrdinalIgnoreCase))
{
rootAttachment = CoveredRootAttachment.HEAD;
}
if (rootAttachment != CoveredRootAttachment.NONE)
{
ppcoveredRootColumn = dataFormatInstance.addInternalColumnDescription(symbolTables, "PPCOVERED", "DEPENDENCY_EDGE_LABEL", "BOOLEAN", "", deprelColumn.NullValueStrategy);
ppcoveredRootSymbolTable = symbolTables.getSymbolTable(ppcoveredRootColumn.Name);
ppcoveredRootSymbolTable.addSymbol("#true#");
ppcoveredRootSymbolTable.addSymbol("#false#");
}
if (liftingOrder.Equals("shortest", StringComparison.OrdinalIgnoreCase))
{
this.liftingOrder = LiftingOrder.SHORTEST;
}
else if (liftingOrder.Equals("deepest", StringComparison.OrdinalIgnoreCase))
{
this.liftingOrder = LiftingOrder.DEEPEST;
}
}