//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void initialize(int containerIndex, org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler, org.maltparser.core.config.ConfigurationDir configDir, int mode) throws org.maltparser.core.exception.MaltChainedException
public virtual void initialize(int containerIndex, DataFormatInstance dataFormatInstance, SymbolTableHandler symbolTableHandler, ConfigurationDir configDir, int mode)
{
optionContainerIndex = containerIndex;
this.mode = mode;
ConfigurationDir = configDir;
startTime = DateTimeHelper.CurrentUnixTimeMillis();
configLogger = initConfigLogger(getOptionValue("config", "logfile").ToString(), getOptionValue("config", "logging").ToString());
this.dataFormatInstance = dataFormatInstance;
this.symbolTableHandler = symbolTableHandler;
parserFactory = makeParserFactory();
if (mode == LEARN)
{
checkOptionDependency();
}
initPropagation();
initFeatureSystem();
initParsingAlgorithm();
if (configLogger.InfoEnabled)
{
URL inputFormatURL = configDir.InputFormatURL;
URL outputFormatURL = configDir.OutputFormatURL;
if (inputFormatURL != null)
{
if (outputFormatURL == null || outputFormatURL.ToString().Equals(inputFormatURL.ToString()))
{
int index = inputFormatURL.ToString().IndexOf('!');
if (index == -1)
{
configLogger.info(" Data Format : " + inputFormatURL.ToString() + "\n");
}
else
{
configLogger.info(" Data Format : " + inputFormatURL.ToString().Substring(index + 1) + "\n");
}
}
else
{
int indexIn = inputFormatURL.ToString().IndexOf('!');
int indexOut = outputFormatURL.ToString().IndexOf('!');
if (indexIn == -1)
{
configLogger.info(" Input Data Format : " + inputFormatURL.ToString() + "\n");
}
else
{
configLogger.info(" Input Data Format : " + inputFormatURL.ToString().Substring(indexIn + 1) + "\n");
}
if (indexOut == -1)
{
configLogger.info(" Output Data Format : " + outputFormatURL.ToString() + "\n");
}
else
{
configLogger.info(" Output Data Format : " + outputFormatURL.ToString().Substring(indexOut + 1) + "\n");
}
}
}
}
}
protected internal SymbolTable edgelabelSymbolTable; // TODO more complex
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public HeadRules(org.apache.log4j.Logger logger, org.maltparser.core.io.dataformat.DataFormatInstance dataFormatInstance, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler) throws org.maltparser.core.exception.MaltChainedException
public HeadRules(Logger logger, DataFormatInstance dataFormatInstance, SymbolTableHandler symbolTableHandler)
{
Logger = logger;
this.dataFormatInstance = dataFormatInstance;
this.symbolTableHandler = symbolTableHandler;
nonTerminalSymbolTable = symbolTableHandler.addSymbolTable("CAT");
edgelabelSymbolTable = symbolTableHandler.addSymbolTable("LABEL");
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public java.util.SortedMap<String,org.maltparser.core.symbol.SymbolTable> getInputSymbolTables(org.maltparser.core.symbol.SymbolTableHandler symbolTables) throws org.maltparser.core.exception.MaltChainedException
public virtual SortedDictionary <string, SymbolTable> getInputSymbolTables(SymbolTableHandler symbolTables)
{
if (inputSymbolTables == null)
{
createInputSymbolTables(symbolTables);
}
return(inputSymbolTables);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public ParseSymbolTableHandler(org.maltparser.core.symbol.SymbolTableHandler parentSymbolTableHandler) throws org.maltparser.core.exception.MaltChainedException
public ParseSymbolTableHandler(SymbolTableHandler parentSymbolTableHandler)
{
this.parentSymbolTableHandler = parentSymbolTableHandler;
symbolTables = new HashMap <string, ParseSymbolTable>();
foreach (string tableName in parentSymbolTableHandler.SymbolTableNames)
{
addSymbolTable(tableName);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public DependencyGraph(org.maltparser.core.symbol.SymbolTableHandler symbolTables) throws org.maltparser.core.exception.MaltChainedException
public DependencyGraph(SymbolTableHandler symbolTables) : base(symbolTables)
{
SingleHeadedConstraint = true;
root = new Root();
root.BelongsToGraph = this;
graphEdges = new SortedSet <Edge.Edge>();
edgePool = new ObjectPoolListAnonymousInnerClass(this);
Clear();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void createColumnDescriptions(org.maltparser.core.symbol.SymbolTableHandler symbolTables, java.util.Map<String, DataFormatEntry> entries, String nullValueStrategy) throws org.maltparser.core.exception.MaltChainedException
private void createColumnDescriptions(SymbolTableHandler symbolTables, IDictionary <string, DataFormatEntry> entries, string nullValueStrategy)
{
foreach (DataFormatEntry entry in entries.Values)
{
ColumnDescription column = new ColumnDescription(entry.DataFormatEntryName, ColumnDescription.getCategory(entry.Category), ColumnDescription.getType(entry.Type), entry.DefaultOutput, nullValueStrategy, false);
symbolTables.addSymbolTable(column.Name, column.Category, column.Type, column.NullValueStrategy);
columnDescriptions.Add(column);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public LWDependencyGraph(org.maltparser.concurrent.graph.dataformat.DataFormat _dataFormat, org.maltparser.core.symbol.SymbolTableHandler _symbolTables, String[] inputTokens, String defaultRootLabel, boolean addEdges) throws org.maltparser.core.exception.MaltChainedException
public LWDependencyGraph(DataFormat _dataFormat, SymbolTableHandler _symbolTables, string[] inputTokens, string defaultRootLabel, bool addEdges)
{
dataFormat = _dataFormat;
symbolTables = _symbolTables;
rootLabels = new RootLabels();
nodes = new List <LWNode>(inputTokens.Length + 1);
comments = new HashMap <int, List <string> >();
resetTokens(inputTokens, defaultRootLabel, addEdges);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public LWDependencyGraph(org.maltparser.concurrent.graph.dataformat.DataFormat _dataFormat, org.maltparser.core.symbol.SymbolTableHandler _symbolTables) throws org.maltparser.core.exception.MaltChainedException
public LWDependencyGraph(DataFormat _dataFormat, SymbolTableHandler _symbolTables)
{
dataFormat = _dataFormat;
symbolTables = _symbolTables;
rootLabels = new RootLabels();
nodes = new List <LWNode>();
nodes.Add(new LWNode(this, 0)); // ROOT
comments = new HashMap <int, List <string> >();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void initInput(String nullValueStategy) throws org.maltparser.core.exception.MaltChainedException
public virtual void initInput(string nullValueStategy)
{
ConfigurationDir configDir = (ConfigurationDir)flowChartinstance.getFlowChartRegistry(typeof(ConfigurationDir), idName);
DataFormatManager dataFormatManager = configDir.DataFormatManager;
SymbolTableHandler symbolTables = configDir.SymbolTables;
inputDataFormatInstance = dataFormatManager.InputDataFormatSpec.createDataFormatInstance(symbolTables, nullValueStategy);
configDir.addDataFormatInstance(dataFormatManager.InputDataFormatSpec.DataFormatName, inputDataFormatInstance);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public ParseSymbolTable(String name, org.maltparser.core.symbol.SymbolTableHandler parentSymbolTableHandler) throws org.maltparser.core.exception.MaltChainedException
public ParseSymbolTable(string name, SymbolTableHandler parentSymbolTableHandler)
{
this.name = name;
type = SymbolTable_Fields.STRING;
parentSymbolTable = parentSymbolTableHandler.addSymbolTable(name);
symbolCodeMap = new HashMap <string, int>();
codeSymbolMap = new HashMap <int, string>();
symbolValueMap = new HashMap <string, double>();
valueCounter = -1;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void initTableHandlers(String decisionSettings, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler) throws org.maltparser.core.exception.MaltChainedException
public virtual void initTableHandlers(string decisionSettings, SymbolTableHandler symbolTableHandler)
{
if (decisionSettings.Equals("T.TRANS+A.DEPREL") || decisionSettings.Equals("T.TRANS#A.DEPREL") || decisionSettings.Equals("T.TRANS,A.DEPREL") || decisionSettings.Equals("T.TRANS;A.DEPREL"))
{
tableHandlers["T"] = transitionTableHandler;
addAvailableTransitionToTable((TransitionTable)transitionTableHandler.addSymbolTable("TRANS"));
tableHandlers["A"] = symbolTableHandler;
return;
}
initTableHandlers(decisionSettingsSplitPattern.split(decisionSettings), decisionSettings, symbolTableHandler);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected void createDependencyEdgeLabelSymbolTables(org.maltparser.core.symbol.SymbolTableHandler symbolTables) throws org.maltparser.core.exception.MaltChainedException
protected internal virtual void createDependencyEdgeLabelSymbolTables(SymbolTableHandler symbolTables)
{
dependencyEdgeLabelSymbolTables = new SortedDictionary <string, SymbolTable>();
foreach (ColumnDescription column in columnDescriptions)
{
if (column.Category == ColumnDescription.DEPENDENCY_EDGE_LABEL)
{
dependencyEdgeLabelSymbolTables[column.Name] = symbolTables.getSymbolTable(column.Name);
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected void createSecondaryEdgeLabelSymbolTables(org.maltparser.core.symbol.SymbolTableHandler symbolTables) throws org.maltparser.core.exception.MaltChainedException
protected internal virtual void createSecondaryEdgeLabelSymbolTables(SymbolTableHandler symbolTables)
{
secondaryEdgeLabelSymbolTables = new SortedDictionary <string, SymbolTable>();
foreach (ColumnDescription column in columnDescriptions)
{
if (column.Category == ColumnDescription.PHRASE_STRUCTURE_EDGE_LABEL)
{
secondaryEdgeLabelSymbolTables[column.Name] = symbolTables.getSymbolTable(column.Name);
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected void createInputSymbolTables(org.maltparser.core.symbol.SymbolTableHandler symbolTables) throws org.maltparser.core.exception.MaltChainedException
protected internal virtual void createInputSymbolTables(SymbolTableHandler symbolTables)
{
inputSymbolTables = new SortedDictionary <string, SymbolTable>();
foreach (ColumnDescription column in columnDescriptions)
{
if (column.Category == ColumnDescription.INPUT)
{
inputSymbolTables[column.Name] = symbolTables.getSymbolTable(column.Name);
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected void createPhraseStructureNodeLabelSymbolTables(org.maltparser.core.symbol.SymbolTableHandler symbolTables) throws org.maltparser.core.exception.MaltChainedException
protected internal virtual void createPhraseStructureNodeLabelSymbolTables(SymbolTableHandler symbolTables)
{
phraseStructureNodeLabelSymbolTables = new SortedDictionary <string, SymbolTable>();
foreach (ColumnDescription column in columnDescriptions)
{
if (column.Category == ColumnDescription.PHRASE_STRUCTURE_NODE_LABEL)
{
phraseStructureNodeLabelSymbolTables[column.Name] = symbolTables.getSymbolTable(column.Name);
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public PhraseStructureGraph(org.maltparser.core.symbol.SymbolTableHandler symbolTables) throws org.maltparser.core.exception.MaltChainedException
public PhraseStructureGraph(SymbolTableHandler symbolTables) : base(symbolTables)
{
root = new Root();
root.BelongsToGraph = this;
graphEdges = new SortedSet <Edge.Edge>();
edgePool = new ObjectPoolListAnonymousInnerClass(this);
nonTerminalNodes = new SortedDictionary <int, NonTerminal>();
nonTerminalPool = new ObjectPoolListAnonymousInnerClass2(this);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static void loadAllMalt04Tagset(org.maltparser.core.options.OptionManager om, int containerIndex, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler, org.apache.log4j.Logger logger) throws org.maltparser.core.exception.MaltChainedException
public static void loadAllMalt04Tagset(OptionManager om, int containerIndex, SymbolTableHandler symbolTableHandler, Logger logger)
{
string malt04Posset = om.getOptionValue(containerIndex, "malt0.4", "posset").ToString();
string malt04Cposset = om.getOptionValue(containerIndex, "malt0.4", "cposset").ToString();
string malt04Depset = om.getOptionValue(containerIndex, "malt0.4", "depset").ToString();
string nullValueStrategy = om.getOptionValue(containerIndex, "singlemalt", "null_value").ToString();
// String rootLabels = om.getOptionValue(containerIndex, "graph", "root_label").toString();
string inputCharSet = om.getOptionValue(containerIndex, "input", "charset").ToString();
loadMalt04Posset(malt04Posset, inputCharSet, nullValueStrategy, symbolTableHandler, logger);
loadMalt04Cposset(malt04Cposset, inputCharSet, nullValueStrategy, symbolTableHandler, logger);
loadMalt04Depset(malt04Depset, inputCharSet, nullValueStrategy, symbolTableHandler, logger);
}
/// <summary>
/// Creates a parsing algorithm
/// </summary>
/// <param name="manager"> a reference to the single malt configuration </param>
/// <param name="symbolTableHandler"> a reference to the symbol table handler </param>
/// <exception cref="MaltChainedException"> </exception>
protected ParsingAlgorithm(IDependencyParserConfig manager, SymbolTableHandler symbolTableHandler)
{
Manager = manager;
ParserRegistry = new ParserRegistry
{
SymbolTableHandler = symbolTableHandler,
DataFormatInstance = Manager.DataFormatInstance
};
ParserRegistry.setAbstractParserFeatureFactory(Manager.ParserFactory);
ParserState = new ParserState(Manager, symbolTableHandler, Manager.ParserFactory);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public ParserState(DependencyParserConfig manager, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler, AbstractParserFactory factory) throws org.maltparser.core.exception.MaltChainedException
public ParserState(IDependencyParserConfig manager, SymbolTableHandler symbolTableHandler, AbstractParserFactory factory)
{
this.factory = factory;
historyStructure = new HistoryList();
transitionSystem = factory.makeTransitionSystem();
string decisionSettings = manager.getOptionValue("guide", "decision_settings").ToString().Trim();
TransitionSystem.initTableHandlers(decisionSettings, symbolTableHandler);
int kBestSize = ((int?)manager.getOptionValue("guide", "kbest")).Value;
string classitem_separator = manager.getOptionValue("guide", "classitem_separator").ToString();
history = new History.History(decisionSettings, classitem_separator, TransitionSystem.TableHandlers, kBestSize);
TransitionSystem.initTransitionSystem(history);
config = factory.makeParserConfiguration();
}
//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 DeterministicParser(DependencyParserConfig manager, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler) throws org.maltparser.core.exception.MaltChainedException
public DeterministicParser(IDependencyParserConfig manager, SymbolTableHandler symbolTableHandler) : base(manager, symbolTableHandler)
{
registry.Algorithm = this;
Guide = new SingleGuide(this, ClassifierGuide_GuideMode.CLASSIFY);
string featureModelFileName = manager.getOptionValue("guide", "features").ToString().Trim();
if (manager.LoggerInfoEnabled)
{
manager.logDebugMessage(" Feature model : " + featureModelFileName + "\n");
manager.logDebugMessage(" Classifier : " + manager.getOptionValueString("guide", "learner") + "\n");
}
string dataSplitColumn = manager.getOptionValue("guide", "data_split_column").ToString().Trim();
string dataSplitStructure = manager.getOptionValue("guide", "data_split_structure").ToString().Trim();
featureModel = manager.FeatureModelManager.getFeatureModel(SingleGuide.findURL(featureModelFileName, manager), 0, ParserRegistry, dataSplitColumn, dataSplitStructure);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected LWEdge(org.maltparser.core.syntaxgraph.node.Node _source, org.maltparser.core.syntaxgraph.node.Node _target, java.util.SortedMap<org.maltparser.concurrent.graph.dataformat.ColumnDescription, String> _labels) throws org.maltparser.core.exception.MaltChainedException
protected internal LWEdge(Node _source, Node _target, SortedDictionary <ColumnDescription, string> _labels)
{
if (_source.BelongsToGraph != _target.BelongsToGraph)
{
throw new LWGraphException("The source node and target node must belong to the same dependency graph.");
}
source = _source;
target = _target;
labels = _labels;
SymbolTableHandler symbolTableHandler = BelongsToGraph.SymbolTables;
foreach (ColumnDescription column in labels.Keys)
{
SymbolTable table = symbolTableHandler.addSymbolTable(column.Name);
table.addSymbol(labels[column]);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void initTableHandlers(String[] decisionElements, String decisionSettings, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler) throws org.maltparser.core.exception.MaltChainedException
public virtual void initTableHandlers(string[] decisionElements, string decisionSettings, SymbolTableHandler symbolTableHandler)
{
int nTrans = 0;
for (int i = 0; i < decisionElements.Length; i++)
{
int index = decisionElements[i].IndexOf('.');
if (index == -1)
{
throw new ParsingException("Decision settings '" + decisionSettings + "' contain an item '" + decisionElements[i] + "' that does not follow the format {TableHandler}.{Table}. ");
}
if (decisionElements[i].Substring(0, index).Equals("T"))
{
if (!tableHandlers.ContainsKey("T"))
{
tableHandlers["T"] = transitionTableHandler;
}
if (decisionElements[i].Substring(index + 1).Equals("TRANS"))
{
if (nTrans == 0)
{
addAvailableTransitionToTable((TransitionTable)transitionTableHandler.addSymbolTable("TRANS"));
}
else
{
throw new ParsingException("Illegal decision settings '" + decisionSettings + "'");
}
nTrans++;
}
}
else if (decisionElements[i].Substring(0, index).Equals("A"))
{
if (!tableHandlers.ContainsKey("A"))
{
tableHandlers["A"] = symbolTableHandler;
}
}
else
{
throw new ParsingException("The decision settings '" + decisionSettings + "' contains an unknown table handler '" + decisionElements[i].Substring(0, index) + "'. " + "Only T (Transition table handler) and A (ArcLabel table handler) is allowed. ");
}
}
}
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 LWDeterministicParser(LWSingleMalt lwSingleMalt, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler) throws org.maltparser.core.exception.MaltChainedException
public LWDeterministicParser(LWSingleMalt lwSingleMalt, SymbolTableHandler symbolTableHandler)
{
manager = lwSingleMalt;
registry = new ParserRegistry();
registry.SymbolTableHandler = symbolTableHandler;
registry.DataFormatInstance = manager.DataFormatInstance;
registry.setAbstractParserFeatureFactory(manager.ParserFactory);
registry.Algorithm = this;
transitionSystem = manager.ParserFactory.makeTransitionSystem();
transitionSystem.initTableHandlers(lwSingleMalt.DecisionSettings, symbolTableHandler);
tableHandlers = transitionSystem.TableHandlers;
kBestSize = lwSingleMalt.getkBestSize();
decisionTables = new List <TableContainer>();
actionTables = new List <TableContainer>();
initDecisionSettings(lwSingleMalt.DecisionSettings, lwSingleMalt.Classitem_separator);
transitionSystem.initTransitionSystem(this);
config = manager.ParserFactory.makeParserConfiguration();
featureModel = manager.FeatureModelManager.getFeatureModel(lwSingleMalt.FeatureModelURL, 0, registry, manager.DataSplitColumn, manager.DataSplitStructure);
currentAction = new ComplexDecisionAction(this);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public ColumnDescription addInternalColumnDescription(org.maltparser.core.symbol.SymbolTableHandler symbolTables, String name, int category, int type, String defaultOutput, String nullValueStrategy) throws org.maltparser.core.exception.MaltChainedException
public virtual ColumnDescription addInternalColumnDescription(SymbolTableHandler symbolTables, string name, int category, int type, string defaultOutput, string nullValueStrategy)
{
if (internalColumnDescriptions == null)
{
internalColumnDescriptions = new SortedDictionary <string, ColumnDescription>();
internalColumnDescriptionSet = new SortedSet <ColumnDescription>();
}
if (!internalColumnDescriptions.ContainsKey(name))
{
ColumnDescription internalColumn = new ColumnDescription(name, category, type, defaultOutput, nullValueStrategy, true);
symbolTables.addSymbolTable(internalColumn.Name, internalColumn.Category, internalColumn.Type, internalColumn.NullValueStrategy);
internalColumnDescriptions[name] = internalColumn;
internalColumnDescriptionSet.Add(internalColumn);
return(internalColumn);
}
else
{
return(internalColumnDescriptions[name]);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public BatchTrainerWithDiagnostics(DependencyParserConfig manager, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler) throws org.maltparser.core.exception.MaltChainedException
public BatchTrainerWithDiagnostics(IDependencyParserConfig manager, SymbolTableHandler symbolTableHandler) : base(manager, symbolTableHandler)
{
diagnostics = new Diagnostics(manager.getOptionValue("singlemalt", "diafile").ToString());
registry.Algorithm = this;
Guide = new SingleGuide(this, ClassifierGuide_GuideMode.BATCH);
string featureModelFileName = manager.getOptionValue("guide", "features").ToString().Trim();
if (manager.LoggerInfoEnabled)
{
manager.logDebugMessage(" Feature model : " + featureModelFileName + "\n");
manager.logDebugMessage(" Learner : " + manager.getOptionValueString("guide", "learner").ToString() + "\n");
}
string dataSplitColumn = manager.getOptionValue("guide", "data_split_column").ToString().Trim();
string dataSplitStructure = manager.getOptionValue("guide", "data_split_structure").ToString().Trim();
featureModel = manager.FeatureModelManager.getFeatureModel(SingleGuide.findURL(featureModelFileName, manager), 0, ParserRegistry, dataSplitColumn, dataSplitStructure);
manager.writeInfoToConfigFile("\nFEATURE MODEL\n");
manager.writeInfoToConfigFile(featureModel.ToString());
oracleGuide = parserState.Factory.makeOracleGuide(parserState.History);
}
/// <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 static void loadMalt04Depset(String fileName, String charSet, String nullValueStrategy, org.maltparser.core.symbol.SymbolTableHandler symbolTableHandler, org.apache.log4j.Logger logger) throws org.maltparser.core.exception.MaltChainedException
public static void loadMalt04Depset(string fileName, string charSet, string nullValueStrategy, SymbolTableHandler symbolTableHandler, Logger logger)
{
if (!fileName.Equals("", StringComparison.OrdinalIgnoreCase))
{
if (logger.InfoEnabled)
{
logger.info("Loading dependency type tagset '" + fileName + "'...\n");
}
symbolTableHandler.loadTagset(fileName, "DEPREL", charSet, ColumnDescription.DEPENDENCY_EDGE_LABEL, ColumnDescription.STRING, nullValueStrategy);
}
}
