MaltParser 1.6.1

Uses of Class
org.maltparser.core.exception.MaltChainedException

Packages that use MaltChainedException
org.maltparser Is the parent package of the entire MaltParser and contains the application class and a console engine of MaltParser. 
org.maltparser.core.config Contains classes and an interface for handling parsing scenarios. 
org.maltparser.core.feature Provides classes for handling feature models. 
org.maltparser.core.feature.function Contains classes and interfaces for handling feature and address functions. 
org.maltparser.core.feature.map Contains classes handling feature map functions. 
org.maltparser.core.feature.spec Contains classes for storing the feature specification model. 
org.maltparser.core.feature.spec.reader Contains classes for loading a feature specification. 
org.maltparser.core.feature.system provides classes to handle the feature system. 
org.maltparser.core.flow   
org.maltparser.core.flow.item   
org.maltparser.core.flow.spec   
org.maltparser.core.flow.system   
org.maltparser.core.flow.system.elem   
org.maltparser.core.helper Provides classes of various kinds that not fit into another package. 
org.maltparser.core.io.dataformat Contains classes for describing the data format, such as CoNLL shared task format and Malt-TAB format. 
org.maltparser.core.options Classes for management of all options used in the application and its plugins. 
org.maltparser.core.options.option Contains classes for types of options. 
org.maltparser.core.plugin Provides classes for loading and initializing plugins. 
org.maltparser.core.pool   
org.maltparser.core.propagation   
org.maltparser.core.propagation.spec   
org.maltparser.core.symbol Contains classes for handling different kinds of symbols (e.g., word forms, root labels and parser actions). 
org.maltparser.core.symbol.nullvalue MaltParser has the possibility of distinguishing between different kinds of null-values when extracting the feature vector. 
org.maltparser.core.symbol.trie Provides classes for handling different kinds of symbols as trie data structure. 
org.maltparser.core.syntaxgraph   
org.maltparser.core.syntaxgraph.ds2ps   
org.maltparser.core.syntaxgraph.edge   
org.maltparser.core.syntaxgraph.feature   
org.maltparser.core.syntaxgraph.headrules   
org.maltparser.core.syntaxgraph.node   
org.maltparser.core.syntaxgraph.reader   
org.maltparser.core.syntaxgraph.writer   
org.maltparser.ml Contains an interface and classes for creating an interface to an machine learning method. 
org.maltparser.ml.lib   
org.maltparser.parser The top package for Single Malt Parser. 
org.maltparser.parser.algorithm.covington Implements the Covington deterministic parsing algorithms. 
org.maltparser.parser.algorithm.nivre Implements the Nivre deterministic parsing algorithms. 
org.maltparser.parser.algorithm.planar   
org.maltparser.parser.algorithm.stack Implements the Stack parsing algorithms. 
org.maltparser.parser.algorithm.twoplanar   
org.maltparser.parser.guide Contains classes that implements the guide, which can be seen as an interface (or glue) between the parsing algorithm and the learner. 
org.maltparser.parser.guide.decision Provides classes for different decision models. 
org.maltparser.parser.guide.instance Provides classes for different instance models. 
org.maltparser.parser.history Contains classes for managing the history feature model. 
org.maltparser.parser.history.action Provides classes for different kinds of parser actions 
org.maltparser.parser.history.container Contains classes for intermediate storing of the parser action 
org.maltparser.parser.history.kbest Contains classes for managing the K-best list 
org.maltparser.parser.transition Contains classes that all deterministic parsing algorithm use (e.g., parser action and transition). 
org.maltparser.transform.pseudo Contains classes for performing pre-processing and post-processing transformations on dependency graphs. 
 

Uses of MaltChainedException in org.maltparser
 

Methods in org.maltparser that throw MaltChainedException
 FlowChartInstance Engine.initialize(int optionContainerIndex)
           
 void MaltParserService.initializeParserModel(String commandLine)
          Initialize a parser model that later can by used to parse sentences.
 DependencyStructure MaltParserService.parse(String[] tokens)
          Parses an array of tokens and returns a dependency structure.
 String[] MaltParserService.parseTokens(String[] tokens)
          Same as parse(String[] tokens), but instead it returns an array of tokens with a head index and a dependency type at the end of string
 void Engine.process(int optionContainerIndex)
           
 DataFormatSpecification MaltParserService.readDataFormatSpecification(String dataFormatFileName)
          Reads the data format specification file
 void MaltParserService.runExperiment(String commandLine)
          Runs a MaltParser experiment.
 void Engine.terminate(int optionContainerIndex)
           
 void MaltParserService.terminateParserModel()
          Terminates the parser model.
 DependencyStructure MaltParserService.toDependencyStructure(String[] tokens)
          Converts an array of tokens to a dependency structure.
 DependencyStructure MaltParserService.toDependencyStructure(String[] tokens, DataFormatSpecification dataFormatSpecification)
          Converts an array of tokens to a dependency structure
 DependencyStructure MaltParserService.toDependencyStructure(String[] tokens, String dataFormatFileName)
          Converts an array of tokens to a dependency structure
 

Constructors in org.maltparser that throw MaltChainedException
Engine()
           
MaltParserService()
          Creates a MaltParserService with the option container 0
MaltParserService(boolean optionFreeInitialization)
          Use this constructor only when you want a MaltParserService without an option manager.
MaltParserService(int optionContainer)
          Creates a MaltParserService with the specified option container.
 

Uses of MaltChainedException in org.maltparser.core.config
 

Subclasses of MaltChainedException in org.maltparser.core.config
 class ConfigurationException
          ConfigurationException extends the MaltChainedException class and is thrown by classes within the configuration package.
 

Methods in org.maltparser.core.config that throw MaltChainedException
protected  void ConfigurationDir.checkConfigDirectory()
           
protected  void ConfigurationDir.checkNConvertConfigVersion()
           
 void ConfigurationDir.copyConfigFile(File in, File out, Versioning versioning)
           
 String ConfigurationDir.copyToConfig(File source)
          Copies a file into the configuration directory.
 String ConfigurationDir.copyToConfig(String fileUrl)
           
 String ConfigurationDir.copyToConfig(URL url)
           
 void ConfigurationDir.createConfigDirectory()
          Creates the configuration directory
 void ConfigurationDir.createConfigFile()
          Creates the malt configuration file (.mco).
protected  void ConfigurationDir.createInfoFile()
           
 void ConfigurationDir.deleteConfigDirectory()
          Removes the configuration directory, if it exists and it contains a .info file.
 void ConfigurationDir.echoInfoFile()
          Prints the content of the configuration information file to the system logger
 OutputStreamWriter ConfigurationDir.getAppendOutputStreamWriter(String fileName)
          This method acts the same as getOutputStreamWriter with the difference that the writer append in the file if it already exists instead of deleting the previous content before starting to write.
 JarEntry ConfigurationDir.getConfigFileEntry(String fileName)
           
 URL ConfigurationDir.getConfigFileEntryURL(String fileName)
           
 File ConfigurationDir.getFile(String fileName)
          Returns a file handler object of a file within the configuration directory
 BufferedWriter ConfigurationDir.getInfoFileWriter()
          Returns a writer to the configuration information file
 InputStream ConfigurationDir.getInputStreamFromConfigFileEntry(String fileName)
           
 InputStreamReader ConfigurationDir.getInputStreamReader(String fileName)
          Creates an input stream reader for reading a file within the configuration directory.
 InputStreamReader ConfigurationDir.getInputStreamReader(String fileName, String charSet)
          Creates an input stream reader for reading a file within the configuration directory
 InputStreamReader ConfigurationDir.getInputStreamReaderFromConfigFile(String fileName)
           
 InputStreamReader ConfigurationDir.getInputStreamReaderFromConfigFileEntry(String fileName, String charSet)
           
 Object Configuration.getOptionValue(String optiongroup, String optionname)
           
 String Configuration.getOptionValueString(String optiongroup, String optionname)
           
 OutputStreamWriter ConfigurationDir.getOutputStreamWriter(String fileName)
          Creates an output stream writer, where the corresponding file will be included in the configuration directory.
 OutputStreamWriter ConfigurationDir.getOutputStreamWriter(String fileName, String charSet)
          Creates an output stream writer, where the corresponding file will be included in the configuration directory
 void ConfigurationDir.initCreatedByMaltParserVersionFromInfoFile()
           
 void ConfigurationDir.initDataFormat()
           
 void ConfigDirChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
           
protected  void ConfigurationDir.initNameNTypeFromInfoFile(URL url)
           
 void ConfigurationDir.initWorkingDirectory()
          Initialize the working directory
 void ConfigurationDir.initWorkingDirectory(String pathPrefixString)
          Initialize the working directory according to the path.
 int ConfigDirChartItem.postprocess(int signal)
           
 int ConfigDirChartItem.preprocess(int signal)
           
 int ConfigDirChartItem.process(int signal)
           
 void ConfigurationDir.terminate()
          Terminates the configuration directory
 void ConfigDirChartItem.terminate()
           
 void ConfigurationDir.unpackConfigFile()
          Unpacks the malt configuration file (.mco).
protected  void ConfigurationDir.unpackConfigFile(JarInputStream jis)
           
 void ConfigurationDir.versioning()
           
 

Constructors in org.maltparser.core.config that throw MaltChainedException
ConfigurationDir(String name, String type, int containerIndex)
          Creates a new configuration directory or a configuration directory from a mco-file
ConfigurationDir(URL url)
          Creates a configuration directory from a mco-file specified by an URL.
 

Uses of MaltChainedException in org.maltparser.core.feature
 

Subclasses of MaltChainedException in org.maltparser.core.feature
 class FeatureException
          FeatureException extends the MaltChainedException class and is thrown by classes within the feature package.
 

Methods in org.maltparser.core.feature that throw MaltChainedException
 FeatureModel FeatureModelManager.getFeatureModel(SpecificationModel specModel, ConfigurationRegistry registry)
           
 FeatureModel FeatureModelManager.getFeatureModel(String specModelURL, ConfigurationRegistry registry)
           
 FeatureModel FeatureModelManager.getFeatureModel(String specModelURL, int specModelUrlIndex, ConfigurationRegistry registry)
           
 FeatureFunction FeatureModel.identifyFeature(String spec)
           
protected  void FeatureModel.identifyFeatureFunction(Stack<Object> objects)
           
protected  void FeatureModel.initializeFunction(Function function, Stack<Object> objects)
           
 void FeatureModelManager.loadParSpecification(String specModelFileName, String markingStrategy, String coveredRoot)
           
 void FeatureModelManager.loadSpecification(String specModelFileName)
           
 Function AbstractFeatureFactory.makeFunction(String subFunctionName)
           
 void FeatureModel.update()
           
 void FeatureVector.update()
          Updates all feature value in the feature vector according to the current state.
 void FeatureModel.update(Object[] arguments)
           
 

Constructors in org.maltparser.core.feature that throw MaltChainedException
FeatureModel(SpecificationModel specModel, ConfigurationRegistry registry, FeatureEngine engine)
           
FeatureModelManager(FeatureEngine engine, ConfigurationDir configDirectory)
           
FeatureVector(FeatureModel featureModel, SpecificationSubModel specSubModel)
          Constructs a feature vector
 

Uses of MaltChainedException in org.maltparser.core.feature.function
 

Methods in org.maltparser.core.feature.function that throw MaltChainedException
 int FeatureFunction.getCode(String symbol)
          Returns the integer representation of the string symbol according to the feature function.
 String FeatureFunction.getSymbol(int code)
          Returns the string representation of the integer code according to the feature function.
 void Function.initialize(Object[] arguments)
          Initialize the feature function
 void Modifiable.setFeatureValue(int code)
          Override the feature value of the feature function.
 void Modifiable.setFeatureValue(String symbol)
          Override the feature value of the feature function.
 void Function.update()
          Cause the feature function to update the feature value.
abstract  void AddressFunction.update(Object[] arguments)
           
 

Uses of MaltChainedException in org.maltparser.core.feature.map
 

Methods in org.maltparser.core.feature.map that throw MaltChainedException
 int SuffixFeature.getCode(String symbol)
           
 int MergeFeature.getCode(String symbol)
           
 int SplitFeature.getCode(String symbol)
           
 int PrefixFeature.getCode(String symbol)
           
 int Merge3Feature.getCode(String symbol)
           
 String SuffixFeature.getSymbol(int code)
           
 String MergeFeature.getSymbol(int code)
           
 String SplitFeature.getSymbol(int code)
           
 String PrefixFeature.getSymbol(int code)
           
 String Merge3Feature.getSymbol(int code)
           
 void SuffixFeature.initialize(Object[] arguments)
           
 void MergeFeature.initialize(Object[] arguments)
           
 void SplitFeature.initialize(Object[] arguments)
           
 void PrefixFeature.initialize(Object[] arguments)
           
 void Merge3Feature.initialize(Object[] arguments)
           
 void SuffixFeature.update()
           
 void MergeFeature.update()
           
 void SplitFeature.update()
           
 void PrefixFeature.update()
           
 void Merge3Feature.update()
           
 void SplitFeature.updateCardinality()
           
 void PrefixFeature.updateCardinality()
           
 void Merge3Feature.updateCardinality()
           
 

Constructors in org.maltparser.core.feature.map that throw MaltChainedException
Merge3Feature(DataFormatInstance dataFormatInstance)
           
MergeFeature(DataFormatInstance dataFormatInstance)
           
PrefixFeature(DataFormatInstance dataFormatInstance)
           
SplitFeature(DataFormatInstance dataFormatInstance)
           
SuffixFeature(DataFormatInstance dataFormatInstance)
           
 

Uses of MaltChainedException in org.maltparser.core.feature.spec
 

Methods in org.maltparser.core.feature.spec that throw MaltChainedException
 void SpecificationModels.add(int index, String featureSpec)
           
 void SpecificationModels.add(int index, String subModelName, String featureSpec)
           
 void SpecificationModel.add(String featureSpec)
           
 void SpecificationModel.add(String subModelName, String featureSpec)
           
 void SpecificationModels.add(String specModelName, String featureSpec)
           
 void SpecificationModels.add(String specModelName, String subModelName, String featureSpec)
           
 void SpecificationModels.load(URL specModelURL)
           
 void SpecificationModels.loadParReader(URL specModelURL, String markingStrategy, String coveredRoot)
           
 

Constructors in org.maltparser.core.feature.spec that throw MaltChainedException
SpecificationModel()
           
SpecificationModel(String specModelName)
           
SpecificationModels()
           
 

Uses of MaltChainedException in org.maltparser.core.feature.spec.reader
 

Methods in org.maltparser.core.feature.spec.reader that throw MaltChainedException
 void ParReader.load(URL specModelURL, SpecificationModels featureSpecModels)
           
 void XmlReader.load(URL specModelURL, SpecificationModels featureSpecModels)
           
 void FeatureSpecReader.load(URL specModelURL, SpecificationModels featureSpecModels)
           
 

Constructors in org.maltparser.core.feature.spec.reader that throw MaltChainedException
ParReader()
           
 

Uses of MaltChainedException in org.maltparser.core.feature.system
 

Methods in org.maltparser.core.feature.system that throw MaltChainedException
 void FeatureEngine.load(PluginLoader plugins)
           
 void FeatureEngine.load(String urlstring)
           
 void FeatureEngine.load(URL specModelURL)
           
 Function FunctionDescription.newFunction(ConfigurationRegistry registry)
           
 Function FeatureEngine.newFunction(String functionName, ConfigurationRegistry registry)
           
 void FeatureEngine.readFeatureSystem(Element system)
           
 void FeatureEngine.readFunction(Element function)
           
 void FeatureEngine.readSubFunction(Element subfunction, Class<?> clazz, boolean hasFactory)
           
 

Uses of MaltChainedException in org.maltparser.core.flow
 

Subclasses of MaltChainedException in org.maltparser.core.flow
 class FlowException
          FlowException extends the MaltChainedException class and is thrown by classes within the flow package.
 

Methods in org.maltparser.core.flow that throw MaltChainedException
protected  ChartItem FlowChartInstance.initChartItem(ChartItemSpecification chartItemSpecification)
           
 FlowChartInstance FlowChartManager.initialize(int optionContainerIndex, String flowChartName)
           
 void FlowChartManager.load(PluginLoader plugins)
           
 void FlowChartManager.load(String urlstring)
           
 void FlowChartManager.load(URL url)
           
 int FlowChartInstance.postprocess()
           
 int FlowChartInstance.preprocess()
           
 int FlowChartInstance.process()
           
 void FlowChartInstance.terminate()
           
 

Constructors in org.maltparser.core.flow that throw MaltChainedException
FlowChartInstance(int optionContainerIndex, ChartSpecification chartSpecification, FlowChartManager flowChartManager)
           
 

Uses of MaltChainedException in org.maltparser.core.flow.item
 

Methods in org.maltparser.core.flow.item that throw MaltChainedException
 void ChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
          Initialize the chart item
abstract  int ChartItem.postprocess(int signal)
          Cause the chart item to perform the postprocess tasks
abstract  int ChartItem.preprocess(int signal)
          Cause the chart item to perform the preprocess tasks
abstract  int ChartItem.process(int signal)
          Cause the chart item to perform the process task (for every sentence)
abstract  void ChartItem.terminate()
          Terminates and cleans up the chart item
 

Uses of MaltChainedException in org.maltparser.core.flow.spec
 

Methods in org.maltparser.core.flow.spec that throw MaltChainedException
 void ChartItemSpecification.read(Element chartItemSpec, FlowChartManager flowCharts)
           
 void ChartSpecification.read(Element chartElem, FlowChartManager flowCharts)
           
 

Uses of MaltChainedException in org.maltparser.core.flow.system
 

Methods in org.maltparser.core.flow.system that throw MaltChainedException
 void FlowChartSystem.load(PluginLoader plugins)
           
 void FlowChartSystem.load(String urlstring)
           
 void FlowChartSystem.load(URL specModelURL)
           
 void FlowChartSystem.readChartElements(Element root)
           
 

Uses of MaltChainedException in org.maltparser.core.flow.system.elem
 

Methods in org.maltparser.core.flow.system.elem that throw MaltChainedException
 void ChartAttribute.read(Element attrElem, FlowChartSystem flowChartSystem)
           
 void ChartElement.read(Element chartElem, FlowChartSystem flowChartSystem)
           
 

Uses of MaltChainedException in org.maltparser.core.helper
 

Methods in org.maltparser.core.helper that throw MaltChainedException
static void Util.copyfile(String source, String destination)
           
 URL URLFinder.findURL(String fileString)
          Search for a file according the following priority: The local file system Specified as an URL (starting with http:, file:, ftp: or jar: MaltParser distribution file (malt.jar) MaltParser plugins If the file string is found, an URL object is returned, otherwise null
 URL URLFinder.findURLinJars(String fileString)
           
static void Malt04.loadAllMalt04Tagset(OptionManager om, int containerIndex, SymbolTableHandler symbolTableHandler, org.apache.log4j.Logger logger)
           
static void Malt04.loadMalt04Cposset(String fileName, String charSet, String nullValueStrategy, SymbolTableHandler symbolTableHandler, org.apache.log4j.Logger logger)
           
static void Malt04.loadMalt04Depset(String fileName, String charSet, String nullValueStrategy, SymbolTableHandler symbolTableHandler, org.apache.log4j.Logger logger)
           
static void Malt04.loadMalt04Posset(String fileName, String charSet, String nullValueStrategy, SymbolTableHandler symbolTableHandler, org.apache.log4j.Logger logger)
           
 

Uses of MaltChainedException in org.maltparser.core.io.dataformat
 

Subclasses of MaltChainedException in org.maltparser.core.io.dataformat
 class DataFormatException
          DataFormatException extends the MaltChainedException class and is thrown by classes within the dataformat package.
 

Methods in org.maltparser.core.io.dataformat that throw MaltChainedException
 ColumnDescription DataFormatInstance.addInternalColumnDescription(String name, ColumnDescription column)
           
 ColumnDescription DataFormatInstance.addInternalColumnDescription(String name, int category, int type, String defaultOutput, String nullValueStrategy)
           
 ColumnDescription DataFormatInstance.addInternalColumnDescription(String name, String category, String type, String defaultOutput, String nullValueStrategy)
           
 DataFormatInstance DataFormatSpecification.createDataFormatInstance(SymbolTableHandler symbolTables, String nullValueStrategy)
           
 DataFormatSpecification DataFormatManager.loadDataFormat(URL dataFormatUrl)
           
 void DataFormatSpecification.parseDataFormatXMLfile(String fileName)
           
 void DataFormatSpecification.parseDataFormatXMLfile(URL url)
           
 

Constructors in org.maltparser.core.io.dataformat that throw MaltChainedException
ColumnDescription(String name, int category, int type, String defaultOutput, SymbolTableHandler symbolTables, String nullValueStrategy, boolean internal)
           
ColumnDescription(String name, String category, String type, String defaultOutput, SymbolTableHandler symbolTables, String nullValueStrategy, boolean internal)
           
DataFormatInstance(Map<String,DataFormatEntry> entries, SymbolTableHandler symbolTables, String nullValueStrategy, DataFormatSpecification spec)
           
DataFormatManager(URL inputFormatUrl, URL outputFormatUrl)
           
 

Uses of MaltChainedException in org.maltparser.core.options
 

Subclasses of MaltChainedException in org.maltparser.core.options
 class OptionException
          OptionException extends the MaltChainedException class and is thrown by classes within the options package.
 

Methods in org.maltparser.core.options that throw MaltChainedException
 void OptionDescriptions.generateMaps()
          Creates several option maps for fast access to individual options.
 void OptionManager.generateMaps()
          Creates several option maps for fast access to individual options.
 Option OptionDescriptions.getOption(String optionflag)
          Returns an option based on the option flag
 Option OptionDescriptions.getOption(String optiongroup, String optionname)
          Returns an option based on the option name and/or the option group name
 Object OptionManager.getOptionDefaultValue(String optiongroup, String optionname)
           
 Object OptionManager.getOptionValue(int containerIndex, String optiongroup, String optionname)
          Returns the option value for an option that is specified by the option group name and option name.
 Object OptionManager.getOptionValueNoDefault(int containerIndex, String optiongroup, String optionname)
           
 String OptionManager.getOptionValueString(int containerIndex, String optiongroup, String optionname)
          Returns a string representation of the option value for an option that is specified by the option group name and the option name.
 String OptionManager.getOptionValueStringNoDefault(int containerIndex, String optiongroup, String optionname)
           
 void OptionManager.loadOptionDescriptionFile()
          Loads the option description file /appdata/options.xml
 void OptionManager.loadOptionDescriptionFile(URL url)
          Loads the option description file
 void OptionManager.loadOptions(int containerIndex, InputStreamReader isr)
          Loads the saved options (options that are marked with usage=Option.SAVE).
 void OptionManager.loadOptions(int containerIndex, String fileName)
          Loads the saved options (options that are marked with usage=save).
 void OptionManager.overloadOptionValue(int containerIndex, String optiongroup, String optionname, String value)
          Overloads the option value specified by the container index, the option group name, the option name.
 boolean OptionManager.parseCommandLine(String[] args, int containerIndex)
          Parses the command line arguments.
 boolean OptionManager.parseCommandLine(String argString, int containerIndex)
           
 void OptionDescriptions.parseOptionDescriptionXMLfile(URL url)
          Parse a XML file that contains the options used for controlling the application.
 void OptionManager.parseOptionInstanceXMLfile(String fileName)
          Parses the option file for option values.
 void OptionManager.saveOptions(int containerIndex, OutputStreamWriter osw)
          Saves all options that are marked as usage=Option.SAVE for a particular option container.
 void OptionManager.saveOptions(int containerIndex, String fileName)
          Saves all options that are marked as usage=Option.SAVE for a particular option container.
 void OptionManager.saveOptions(OutputStreamWriter osw)
          Saves all options that are marked as usage=Option.SAVE
 void OptionManager.saveOptions(String fileName)
          Saves all options that are marked as usage=Option.SAVE
 String OptionManager.toStringPrettyValues(int containerIndex, Set<String> excludeGroups)
          Returns a string representation of all option value, except the options in a option group specified by the excludeGroup argument.
 

Uses of MaltChainedException in org.maltparser.core.options.option
 

Methods in org.maltparser.core.options.option that throw MaltChainedException
 void EnumOption.addLegalValue(String value)
          Adds a legal value without a description
 void EnumOption.addLegalValue(String value, String desc)
          Adds a legal value
 void StringEnumOption.addLegalValue(String value, String desc, String mapto)
          Adds a legal value that corresponds to another string
 void ClassOption.addLegalValue(String value, String desc, String classname)
          Adds a legal value that corresponds to a class
abstract  Object Option.getDefaultValueObject()
          Returns the object for the default value for option.
 Object BoolOption.getDefaultValueObject()
           
 Object StringEnumOption.getDefaultValueObject()
           
 Object IntegerOption.getDefaultValueObject()
           
 Object UnaryOption.getDefaultValueObject()
           
 Object EnumOption.getDefaultValueObject()
           
 Object StringOption.getDefaultValueObject()
           
 String StringEnumOption.getLegalValueMapToString(String value)
          Returns the mapped legal value
 String ClassOption.getLegalValueString(Class<?> clazz)
          Returns a string representation of particular class
 String StringEnumOption.getLegalValueString(String value)
          Returns the legal value identifier name (an enumerate string value)
abstract  Object Option.getValueObject(String value)
          Returns the corresponding object for the option value (specified as a string value).
 Object BoolOption.getValueObject(String value)
           
 Object StringEnumOption.getValueObject(String value)
           
 Object IntegerOption.getValueObject(String value)
           
 Object UnaryOption.getValueObject(String value)
           
 Object ClassOption.getValueObject(String value)
           
 Object EnumOption.getValueObject(String value)
           
 Object StringOption.getValueObject(String value)
           
abstract  void Option.setDefaultValue(String defaultValue)
          Sets the default value for the option.
 void BoolOption.setDefaultValue(String defaultValue)
           
 void StringEnumOption.setDefaultValue(String defaultValue)
           
 void IntegerOption.setDefaultValue(String defaultValue)
           
 void UnaryOption.setDefaultValue(String defaultValue)
           
 void ClassOption.setDefaultValue(String defaultValue)
           
 void EnumOption.setDefaultValue(String defaultValue)
           
 void Option.setFlag(String flag)
          Sets a character that is used as a flag for the command line input
 void Option.setName(String name)
          Sets the name of the option.
 void Option.setUsage(int usage)
          Sets the usage of the option.
 void Option.setUsage(String usage)
          Sets the usage of the option.
 

Constructors in org.maltparser.core.options.option that throw MaltChainedException
BoolOption(OptionGroup group, String name, String shortDescription, String flag, String usage, String defaultValue)
          Creates a boolean option description
ClassOption(OptionGroup group, String name, String shortDescription, String flag, String usage)
          Creates a class type option description
EnumOption(OptionGroup group, String name, String shortDescription, String flag, String usage)
          Creates an enumerate option description
IntegerOption(OptionGroup group, String name, String shortDescription, String flag, String usage, String defaultValue)
          Creates an integer option description
Option(OptionGroup group, String name, String shortDescription, String flag, String usage)
          Creates an option description
StringEnumOption(OptionGroup group, String name, String shortDescription, String flag, String usage)
          Creates a stringenum type option description
StringOption(OptionGroup group, String name, String shortDescription, String flag, String usage, String defaultValue)
          Creates a string option description
UnaryOption(OptionGroup group, String name, String shortDescription, String flag, String usage)
          Creates an unary option description
 

Uses of MaltChainedException in org.maltparser.core.plugin
 

Subclasses of MaltChainedException in org.maltparser.core.plugin
 class PluginException
          PluginException extends the MaltChainedException class and is thrown by classes within the plugin package.
 

Methods in org.maltparser.core.plugin that throw MaltChainedException
 void PluginLoader.loadPlugins(File pluginDirectory)
          Loads plug-ins from one directory
 void PluginLoader.loadPlugins(File[] pluginDirectories)
          Loads plug-ins from one or more directories
 Object PluginLoader.newInstance(String classname, Class<?>[] argTypes, Object[] args)
          Creates a new instance of a class within one of the plug-ins
 boolean JarLoader.readJarFile(URL jarUrl)
          Loads the content of a jar file that comply with a MaltParser Plugin
 

Constructors in org.maltparser.core.plugin that throw MaltChainedException
Plugin(File file)
          Creates a plug-in container.
Plugin(String filename)
          Creates a plug-in container.
 

Uses of MaltChainedException in org.maltparser.core.pool
 

Methods in org.maltparser.core.pool that throw MaltChainedException
abstract  void ObjectPool.checkIn(T o)
           
 void ObjectPoolList.checkIn(T o)
           
 void ObjectPoolSet.checkIn(T t)
           
abstract  void ObjectPool.checkInAll()
           
 void ObjectPoolList.checkInAll()
           
 void ObjectPoolSet.checkInAll()
           
abstract  T ObjectPool.checkOut()
           
 T ObjectPoolList.checkOut()
           
 T ObjectPoolSet.checkOut()
           
protected abstract  T ObjectPool.create()
           
protected abstract  T ObjectPoolList.create()
           
protected abstract  T ObjectPoolSet.create()
           
abstract  void ObjectPool.resetObject(T o)
           
abstract  void ObjectPoolList.resetObject(T o)
           
abstract  void ObjectPoolSet.resetObject(T o)
           
 

Uses of MaltChainedException in org.maltparser.core.propagation
 

Subclasses of MaltChainedException in org.maltparser.core.propagation
 class PropagationException
          PropagationException extends the MaltChainedException class and is thrown by classes within the propagation package.
 

Methods in org.maltparser.core.propagation that throw MaltChainedException
 void PropagationManager.loadSpecification(String propagationSpecFileName)
           
 void Propagations.propagate(Edge e)
           
 void PropagationManager.propagate(Edge e)
           
 void Propagation.propagate(Edge e)
          Propagate columns according to the propagation specification
 

Constructors in org.maltparser.core.propagation that throw MaltChainedException
Propagation(PropagationSpec spec, DataFormatInstance dataFormatInstance)
          Creates a propagation object based on the propagation specification
Propagations(PropagationSpecs specs, DataFormatInstance dataFormatInstance)
           
 

Uses of MaltChainedException in org.maltparser.core.propagation.spec
 

Methods in org.maltparser.core.propagation.spec that throw MaltChainedException
 void PropagationSpecsReader.load(URL url, PropagationSpecs propagationSpecs)
           
 

Uses of MaltChainedException in org.maltparser.core.symbol
 

Subclasses of MaltChainedException in org.maltparser.core.symbol
 class SymbolException
          SymbolException extends the MaltChainedException class and is thrown by classes within the symbol package.
 

Methods in org.maltparser.core.symbol that throw MaltChainedException
 int Table.addSymbol(String symbol)
           
 int SymbolTable.addSymbol(StringBuilder symbol)
           
 SymbolTable SymbolTableHandler.addSymbolTable(String tableName)
           
 Table TableHandler.addSymbolTable(String tableName)
           
 SymbolTable SymbolTableHandler.addSymbolTable(String tableName, int columnCategory, String nullValueStrategy)
           
 SymbolTable SymbolTableHandler.addSymbolTable(String tableName, SymbolTable parentTable)
           
 void SymbolTable.copy(SymbolTable fromTable)
           
 int TableFeature.getCode(String value)
           
 int SymbolTable.getNullValueCode(NullValues.NullValueId nullValueIdentifier)
           
 String SymbolTable.getNullValueSymbol(NullValues.NullValueId nullValueIdentifier)
           
 String TableFeature.getSymbol(int value)
           
 String Table.getSymbolCodeToString(int code)
           
 int Table.getSymbolStringToCode(String symbol)
           
 SymbolTable SymbolTableHandler.getSymbolTable(String tableName)
           
 Table TableHandler.getSymbolTable(String tableName)
           
abstract  void TableFeature.initialize(Object[] arguments)
           
 boolean SymbolTable.isNullValue(int code)
           
 boolean SymbolTable.isNullValue(String value)
           
 void SymbolTable.load(BufferedReader in)
           
 void SymbolTableHandler.load(InputStreamReader isr)
           
 void SymbolTableHandler.load(String fileName, String charSet)
           
 SymbolTable SymbolTableHandler.loadTagset(String fileName, String tableName, String charSet, int columnCategory, String nullValueStrategy)
           
 void SymbolTable.printSymbolTable(org.apache.log4j.Logger logger)
           
 void SymbolTableHandler.printSymbolTables(org.apache.log4j.Logger logger)
           
 void SymbolTable.save(BufferedWriter out)
           
 void SymbolTableHandler.save(OutputStreamWriter osw)
           
 void SymbolTableHandler.save(String fileName, String charSet)
           
 void TableFeature.setFeatureValue(int indexCode)
           
 void TableFeature.setFeatureValue(String symbol)
           
abstract  void TableFeature.update()
           
 

Constructors in org.maltparser.core.symbol that throw MaltChainedException
TableFeature()
           
 

Uses of MaltChainedException in org.maltparser.core.symbol.nullvalue
 

Methods in org.maltparser.core.symbol.nullvalue that throw MaltChainedException
 int NullValues.nullvalueToCode(NullValues.NullValueId nullValueIdentifier)
           
 String NullValues.nullvalueToSymbol(NullValues.NullValueId nullValueIdentifier)
           
 

Uses of MaltChainedException in org.maltparser.core.symbol.trie
 

Methods in org.maltparser.core.symbol.trie that throw MaltChainedException
 int TrieSymbolTable.addSymbol(String symbol)
           
 int TrieSymbolTable.addSymbol(StringBuilder symbol)
           
 TrieSymbolTable TrieSymbolTableHandler.addSymbolTable(String tableName)
           
 TrieSymbolTable TrieSymbolTableHandler.addSymbolTable(String tableName, int columnCategory, String nullValueStrategy)
           
 TrieSymbolTable TrieSymbolTableHandler.addSymbolTable(String tableName, SymbolTable parentTable)
           
 void TrieSymbolTable.copy(SymbolTable fromTable)
           
 int TrieSymbolTable.getNullValueCode(NullValues.NullValueId nullValueIdentifier)
           
 String TrieSymbolTable.getNullValueSymbol(NullValues.NullValueId nullValueIdentifier)
           
 String TrieSymbolTable.getSymbolCodeToString(int code)
           
 int TrieSymbolTable.getSymbolStringToCode(String symbol)
           
 boolean TrieSymbolTable.isNullValue(int code)
           
 boolean TrieSymbolTable.isNullValue(String symbol)
           
 void TrieSymbolTable.load(BufferedReader in)
           
 void TrieSymbolTableHandler.load(InputStreamReader isr)
           
 void TrieSymbolTableHandler.load(String fileName, String charSet)
           
 void TrieSymbolTableHandler.loadHeader(BufferedReader bin)
           
 SymbolTable TrieSymbolTableHandler.loadTagset(String fileName, String tableName, String charSet, int columnCategory, String nullValueStrategy)
           
 void TrieSymbolTable.printSymbolTable(org.apache.log4j.Logger logger)
           
 void TrieSymbolTableHandler.printSymbolTables(org.apache.log4j.Logger logger)
           
 void TrieSymbolTable.save(BufferedWriter out)
           
 void TrieSymbolTableHandler.save(OutputStreamWriter osw)
           
 void TrieSymbolTableHandler.save(String fileName, String charSet)
           
 void TrieSymbolTable.saveHeader(BufferedWriter out)
           
 

Constructors in org.maltparser.core.symbol.trie that throw MaltChainedException
TrieSymbolTable(String name, Trie trie, int columnCategory, String nullValueStrategy, int symbolTableMode)
           
 

Uses of MaltChainedException in org.maltparser.core.syntaxgraph
 

Subclasses of MaltChainedException in org.maltparser.core.syntaxgraph
 class SyntaxGraphException
          GraphException extends the MaltChainedException class and is thrown by classes within the graph package.
 

Methods in org.maltparser.core.syntaxgraph that throw MaltChainedException
protected  Edge DependencyGraph.addDependencyEdge(DependencyNode head, DependencyNode dependent)
           
 Edge MappablePhraseStructureGraph.addDependencyEdge(DependencyNode head, DependencyNode dependent)
           
 Edge DependencyGraph.addDependencyEdge(int headIndex, int dependentIndex)
           
 Edge DependencyStructure.addDependencyEdge(int headIndex, int dependentIndex)
          Adds an edge from the head to the dependent identified by the indices of the dependency nodes.
 Edge MappablePhraseStructureGraph.addDependencyEdge(int headIndex, int dependentIndex)
           
 DependencyNode DependencyGraph.addDependencyNode()
           
 DependencyNode DependencyStructure.addDependencyNode()
           
 DependencyNode MappablePhraseStructureGraph.addDependencyNode()
           
 DependencyNode DependencyGraph.addDependencyNode(int index)
           
 DependencyNode DependencyStructure.addDependencyNode(int index)
           
 DependencyNode MappablePhraseStructureGraph.addDependencyNode(int index)
           
 void LabeledStructure.addLabel(Element element, String tableName, String label)
          Adds a label label to the graph element element
 void SyntaxGraph.addLabel(Element element, String labelFunction, String label)
           
 void MappablePhraseStructureGraph.addLabel(Element element, String labelFunction, String label)
           
 void Element.addLabel(LabelSet labelSet)
          Adds the labels of the label set to the label set of the graph element.
 void GraphElement.addLabel(LabelSet labels)
          Adds the labels of the label set to the label set of the graph element.
 void Element.addLabel(SymbolTable table, int code)
          Adds a label (an integer value) to the symbol table and to the graph element.
 void GraphElement.addLabel(SymbolTable table, int code)
          Adds a label (an integer value) to the symbol table and to the graph element.
 void Element.addLabel(SymbolTable table, String symbol)
          Adds a label (a string value) to the symbol table and to the graph element.
 void GraphElement.addLabel(SymbolTable table, String symbol)
          Adds a label (a string value) to the symbol table and to the graph element.
 PhraseStructureNode PhraseStructure.addNonTerminalNode()
           
 PhraseStructureNode PhraseStructureGraph.addNonTerminalNode()
           
 PhraseStructureNode MappablePhraseStructureGraph.addNonTerminalNode()
           
 PhraseStructureNode PhraseStructure.addNonTerminalNode(int index)
           
 PhraseStructureNode PhraseStructureGraph.addNonTerminalNode(int index)
           
 PhraseStructureNode MappablePhraseStructureGraph.addNonTerminalNode(int index)
           
 Edge PhraseStructure.addPhraseStructureEdge(PhraseStructureNode source, PhraseStructureNode target)
           
 Edge PhraseStructureGraph.addPhraseStructureEdge(PhraseStructureNode parent, PhraseStructureNode child)
           
 Edge MappablePhraseStructureGraph.addPhraseStructureEdge(PhraseStructureNode parent, PhraseStructureNode child)
           
 Edge DependencyGraph.addSecondaryEdge(ComparableNode source, ComparableNode target)
           
 Edge SecEdgeStructure.addSecondaryEdge(ComparableNode source, ComparableNode target)
           
 Edge PhraseStructureGraph.addSecondaryEdge(ComparableNode source, ComparableNode target)
           
 Edge MappablePhraseStructureGraph.addSecondaryEdge(ComparableNode source, ComparableNode target)
           
 PhraseStructureNode PhraseStructure.addTerminalNode()
           
 PhraseStructureNode PhraseStructureGraph.addTerminalNode()
           
 PhraseStructureNode MappablePhraseStructureGraph.addTerminalNode()
           
 PhraseStructureNode PhraseStructure.addTerminalNode(int index)
           
 PhraseStructureNode PhraseStructureGraph.addTerminalNode(int index)
           
 PhraseStructureNode MappablePhraseStructureGraph.addTerminalNode(int index)
           
 TokenNode TokenStructure.addTokenNode()
          Adds a token node with index n + 1, where n is the index of the last token node.
 TokenNode Sentence.addTokenNode()
           
 TokenNode TokenStructure.addTokenNode(int index)
          Adds a token node with index index.
 TokenNode Sentence.addTokenNode(int index)
           
 void LabeledStructure.checkInLabelSet(LabelSet labelSet)
          Checks in a label set.
 void SyntaxGraph.checkInLabelSet(LabelSet labelSet)
           
 LabelSet LabeledStructure.checkOutNewLabelSet()
          Checks out a new label set from the structure.
 LabelSet SyntaxGraph.checkOutNewLabelSet()
           
 void Structure.clear()
          Resets the structure.
 void DependencyGraph.clear()
           
 void Element.clear()
          Resets the graph element.
 void GraphElement.clear()
          Resets the graph element.
 void Sentence.clear()
           
 void SyntaxGraph.clear()
           
 void PhraseStructureGraph.clear()
           
 void MappablePhraseStructureGraph.clear()
           
 void CopyChartItem.copyPartialDependencyStructure(DependencyStructure sourceGraph, DependencyStructure targetGraph)
           
 void CopyChartItem.copyTerminalStructure(TokenStructure sourceGraph, TokenStructure targetGraph)
           
 int DependencyGraph.getDefaultRootEdgeLabelCode(SymbolTable table)
           
 int DependencyStructure.getDefaultRootEdgeLabelCode(SymbolTable table)
          Returns the default edge label of the root as an integer value.
 int MappablePhraseStructureGraph.getDefaultRootEdgeLabelCode(SymbolTable table)
           
 LabelSet DependencyGraph.getDefaultRootEdgeLabels()
           
 LabelSet DependencyStructure.getDefaultRootEdgeLabels()
           
 LabelSet MappablePhraseStructureGraph.getDefaultRootEdgeLabels()
           
 String DependencyGraph.getDefaultRootEdgeLabelSymbol(SymbolTable table)
           
 String DependencyStructure.getDefaultRootEdgeLabelSymbol(SymbolTable table)
          Returns the default edge label of the root as a string value.
 String MappablePhraseStructureGraph.getDefaultRootEdgeLabelSymbol(SymbolTable table)
           
 Integer RootLabels.getDefaultRootLabelCode(SymbolTable table)
           
 LabelSet RootLabels.getDefaultRootLabels()
           
 String RootLabels.getDefaultRootLabelSymbol(SymbolTable table)
           
 DependencyNode DependencyGraph.getDependencyNode(int index)
           
 DependencyNode DependencyStructure.getDependencyNode(int index)
          Returns the dependency node identified by index if it exists, otherwise null.
 DependencyNode MappablePhraseStructureGraph.getDependencyNode(int index)
           
 int Element.getLabelCode(SymbolTable table)
          Returns the label code (an integer representation) of the symbol table if it exists, otherwise an exception is thrown.
 int GraphElement.getLabelCode(SymbolTable table)
          Returns the label code (an integer representation) of the symbol table if it exists, otherwise an exception is thrown.
 String Element.getLabelSymbol(SymbolTable table)
          Returns the label symbol(a string representation) of the symbol table if it exists, otherwise an exception is thrown.
 String GraphElement.getLabelSymbol(SymbolTable table)
          Returns the label symbol(a string representation) of the symbol table if it exists, otherwise an exception is thrown.
 PhraseStructureNode PhraseStructure.getNonTerminalNode(int index)
           
 PhraseStructureNode PhraseStructureGraph.getNonTerminalNode(int index)
           
 PhraseStructureNode MappablePhraseStructureGraph.getNonTerminalNode(int index)
           
protected  Token Sentence.getOrAddTerminalNode(int index)
           
 boolean Element.hasLabel(SymbolTable table)
          Returns true if the graph element has a label for the symbol table, otherwise false.
 boolean GraphElement.hasLabel(SymbolTable table)
          Returns true if the graph element has a label for the symbol table, otherwise false.
 boolean DependencyGraph.hasLabeledDependency(int index)
           
 boolean DependencyStructure.hasLabeledDependency(int index)
          Returns true if the head edge of the dependency node with index is labeled, otherwise false.
 boolean MappablePhraseStructureGraph.hasLabeledDependency(int index)
           
 void CopyChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
           
 void GraphAnalyzerChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
           
 void SyntaxGraphChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
           
 boolean DependencyGraph.isProjective()
           
 boolean DependencyStructure.isProjective()
          Returns true if all edges in the dependency structure are projective, otherwise false.
 boolean MappablePhraseStructureGraph.isProjective()
           
 void MappablePhraseStructureGraph.linkAllTerminalsToRoot()
           
 void DependencyGraph.linkAllTreesToRoot()
           
 void DependencyStructure.linkAllTreesToRoot()
          Links all subtrees to the root of the dependency structure.
 void MappablePhraseStructureGraph.linkAllTreesToRoot()
           
protected  Edge DependencyGraph.moveDependencyEdge(DependencyNode newHead, DependencyNode dependent)
           
 Edge MappablePhraseStructureGraph.moveDependencyEdge(DependencyNode newHead, DependencyNode dependent)
           
 Edge DependencyGraph.moveDependencyEdge(int newHeadIndex, int dependentIndex)
           
 Edge DependencyStructure.moveDependencyEdge(int newHeadIndex, int dependentIndex)
          Replace the head of the dependent with a new head.
 Edge MappablePhraseStructureGraph.moveDependencyEdge(int newHeadIndex, int dependentIndex)
           
 int DependencyGraph.nNonProjectiveEdges()
           
 int DependencyStructure.nNonProjectiveEdges()
          Returns the number of non-projective edges in the dependency structure.
 int MappablePhraseStructureGraph.nNonProjectiveEdges()
           
 int CopyChartItem.postprocess(int signal)
           
 int GraphAnalyzerChartItem.postprocess(int signal)
           
 int SyntaxGraphChartItem.postprocess(int signal)
           
 int CopyChartItem.preprocess(int signal)
           
 int GraphAnalyzerChartItem.preprocess(int signal)
           
 int SyntaxGraphChartItem.preprocess(int signal)
           
 int CopyChartItem.process(int signal)
           
 int GraphAnalyzerChartItem.process(int signal)
           
 int SyntaxGraphChartItem.process(int signal)
           
 void DependencyGraph.removeDependencyEdge(int headIndex, int dependentIndex)
           
 void DependencyStructure.removeDependencyEdge(int headIndex, int dependentIndex)
          Remove an edge from the head to the dependent identified by the indices of the dependency nodes.
 void MappablePhraseStructureGraph.removeDependencyEdge(int headIndex, int dependentIndex)
           
protected  void DependencyGraph.removeDependencyEdge(Node head, Node dependent)
           
protected  void MappablePhraseStructureGraph.removeDependencyEdge(Node head, Node dependent)
           
 void Element.removeLabel(SymbolTable table)
           
 void GraphElement.removeLabel(SymbolTable table)
           
 void Element.removeLabels()
           
 void GraphElement.removeLabels()
           
 void PhraseStructure.removePhraseStructureEdge(PhraseStructureNode source, PhraseStructureNode target)
           
 void PhraseStructureGraph.removePhraseStructureEdge(PhraseStructureNode parent, PhraseStructureNode child)
           
 void MappablePhraseStructureGraph.removePhraseStructureEdge(PhraseStructureNode parent, PhraseStructureNode child)
           
 void DependencyGraph.removeSecondaryEdge(ComparableNode source, ComparableNode target)
           
 void SecEdgeStructure.removeSecondaryEdge(ComparableNode source, ComparableNode target)
           
 void PhraseStructureGraph.removeSecondaryEdge(ComparableNode source, ComparableNode target)
           
 void MappablePhraseStructureGraph.removeSecondaryEdge(ComparableNode source, ComparableNode target)
           
 void DependencyGraph.setDefaultRootEdgeLabel(SymbolTable table, String defaultRootSymbol)
           
 void DependencyStructure.setDefaultRootEdgeLabel(SymbolTable table, String defaultRootSymbol)
          Sets the default edge label of the root.
 void MappablePhraseStructureGraph.setDefaultRootEdgeLabel(SymbolTable table, String defaultRootSymbol)
           
 void DependencyGraph.setDefaultRootEdgeLabels(String rootLabelOption, SortedMap<String,SymbolTable> edgeSymbolTables)
           
 void DependencyStructure.setDefaultRootEdgeLabels(String rootLabelOption, SortedMap<String,SymbolTable> edgeSymbolTables)
          Sets the default edge label of the root according to the default root label option
 void MappablePhraseStructureGraph.setDefaultRootEdgeLabels(String rootLabelOption, SortedMap<String,SymbolTable> edgeSymbolTables)
           
 void RootLabels.setDefaultRootLabel(SymbolTable table, String defaultRootSymbol)
           
 void RootLabels.setRootLabels(String rootLabelOption, SortedMap<String,SymbolTable> edgeSymbolTables)
           
 void CopyChartItem.terminate()
           
 void GraphAnalyzerChartItem.terminate()
           
 void SyntaxGraphChartItem.terminate()
           
 

Constructors in org.maltparser.core.syntaxgraph that throw MaltChainedException
DependencyGraph(SymbolTableHandler symbolTables)
           
MappablePhraseStructureGraph(SymbolTableHandler symbolTables)
           
PhraseStructureGraph(SymbolTableHandler symbolTables)
           
Sentence(SymbolTableHandler symbolTables)
           
SyntaxGraph(SymbolTableHandler symbolTables)
           
 

Uses of MaltChainedException in org.maltparser.core.syntaxgraph.ds2ps
 

Methods in org.maltparser.core.syntaxgraph.ds2ps that throw MaltChainedException
 void LosslessMapping.connectUnattachedSpines(MappablePhraseStructureGraph graph)
           
 void LosslessMapping.setHeadRules(String headRulesURL)
           
 void LosslessMapping.update(MappablePhraseStructureGraph graph, Edge e, Object arg)
           
 void LosslessMapping.updateDependenyGraph(MappablePhraseStructureGraph graph, PhraseStructureNode top)
           
 void LosslessMapping.updatePhraseStructureGraph(MappablePhraseStructureGraph graph, Edge depEdge, boolean attachHeadSpineToRoot)
           
 

Uses of MaltChainedException in org.maltparser.core.syntaxgraph.edge
 

Methods in org.maltparser.core.syntaxgraph.edge that throw MaltChainedException
 void WeightedEdge.clear()
           
 void GraphEdge.clear()
           
 void Edge.setEdge(Node source, Node target, int type)
          Sets the edge with a source node, a target node and a type (DEPENDENCY_EDGE, PHRASE_STRUCTURE_EDGE or SECONDARY_EDGE).
 void GraphEdge.setEdge(Node source, Node target, int type)
          Sets the edge with a source node, a target node and a type (DEPENDENCY_EDGE, PHRASE_STRUCTURE_EDGE or SECONDARY_EDGE).
 

Constructors in org.maltparser.core.syntaxgraph.edge that throw MaltChainedException
GraphEdge(Node source, Node target, int type)
           
WeightedEdge(Node source, Node target, int type)
           
WeightedEdge(Node source, Node target, int type, Double weight)
           
 

Uses of MaltChainedException in org.maltparser.core.syntaxgraph.feature
 

Methods in org.maltparser.core.syntaxgraph.feature that throw MaltChainedException
protected  void ColumnFeature.castFeatureValue(String symbol)
           
 int NumOfFeature.getCode(String symbol)
          Returns the integer representation of the string symbol according to the numof feature function.
 int InputArcDirFeature.getCode(String symbol)
           
 int DistanceFeature.getCode(String symbol)
          Returns the integer representation of the string symbol according to the distance feature function.
 int ArcDirFeature.getCode(String symbol)
          Returns the integer representation of the string symbol according to the exists feature function.
 int ExistsFeature.getCode(String symbol)
          Returns the integer representation of the string symbol according to the exists feature function.
 int InputArcFeature.getCode(String symbol)
           
 int ColumnFeature.getCode(String value)
           
 int OutputArcFeature.getCode(String symbol)
           
 String NumOfFeature.getSymbol(int code)
          Returns the string representation of the integer code according to the numof feature function.
 String InputArcDirFeature.getSymbol(int code)
           
 String DistanceFeature.getSymbol(int code)
          Returns the string representation of the integer code according to the distance feature function.
 String ArcDirFeature.getSymbol(int code)
          Returns the string representation of the integer code according to the exists feature function.
 String ExistsFeature.getSymbol(int code)
          Returns the string representation of the integer code according to the exists feature function.
 String InputArcFeature.getSymbol(int code)
           
 String ColumnFeature.getSymbol(int value)
           
 String OutputArcFeature.getSymbol(int code)
           
 void OutputColumnFeature.initialize(Object[] arguments)
           
 void NumOfFeature.initialize(Object[] arguments)
          Initialize the distance feature function
 void InputArcDirFeature.initialize(Object[] arguments)
           
 void DistanceFeature.initialize(Object[] arguments)
          Initialize the distance feature function
 void ArcDirFeature.initialize(Object[] arguments)
          Initialize the exists feature function
 void InputColumnFeature.initialize(Object[] arguments)
           
 void InputTableFeature.initialize(Object[] arguments)
           
 void OutputTableFeature.initialize(Object[] arguments)
           
 void ExistsFeature.initialize(Object[] arguments)
          Initialize the exists feature function
 void InputArcFeature.initialize(Object[] arguments)
           
abstract  void ColumnFeature.initialize(Object[] arguments)
           
 void OutputArcFeature.initialize(Object[] arguments)
           
 void DGraphAddressFunction.initialize(Object[] arguments)
           
 void InputArcDirFeature.setColumn(ColumnDescription column)
           
 void InputArcFeature.setColumn(ColumnDescription column)
           
 void OutputArcFeature.setColumn(ColumnDescription column)
           
 void ColumnFeature.setFeatureValue(int indexCode)
           
 void ColumnFeature.setFeatureValue(String symbol)
           
 void OutputColumnFeature.update()
           
 void NumOfFeature.update()
          Cause the feature function to update the feature value.
 void InputArcDirFeature.update()
           
 void DistanceFeature.update()
          Cause the feature function to update the feature value.
 void ArcDirFeature.update()
          Cause the feature function to update the feature value.
 void InputColumnFeature.update()
           
 void InputTableFeature.update()
           
 void OutputTableFeature.update()
           
 void ExistsFeature.update()
          Cause the feature function to update the feature value.
 void InputArcFeature.update()
           
abstract  void ColumnFeature.update()
           
 void OutputArcFeature.update()
           
 void DGraphAddressFunction.update()
           
 void DGraphAddressFunction.update(Object[] arguments)
           
 void InputArcDirFeature.updateCardinality()
           
 void InputArcFeature.updateCardinality()
           
 void OutputArcFeature.updateCardinality()
           
 

Constructors in org.maltparser.core.syntaxgraph.feature that throw MaltChainedException
ArcDirFeature(SymbolTableHandler tableHandler)
           
ColumnFeature()
           
DistanceFeature(SymbolTableHandler tableHandler)
           
ExistsFeature(SymbolTableHandler tableHandler)
           
InputArcDirFeature(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler)
           
InputArcFeature(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler)
           
InputColumnFeature(DataFormatInstance dataFormatInstance)
           
InputTableFeature(DataFormatInstance dataFormatInstance)
           
NumOfFeature(SymbolTableHandler tableHandler)
           
OutputArcFeature(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler)
           
OutputColumnFeature(DataFormatInstance dataFormatInstance)
           
OutputTableFeature(DataFormatInstance dataFormatInstance)
           
 

Uses of MaltChainedException in org.maltparser.core.syntaxgraph.headrules
 

Subclasses of MaltChainedException in org.maltparser.core.syntaxgraph.headrules
 class HeadRuleException
          HeadRuleException extends the MaltChainedException class and is thrown by classes within the headrule package.
 

Methods in org.maltparser.core.syntaxgraph.headrules that throw MaltChainedException
 PrioSetMember PrioSet.addPrioSetMember(SymbolTable table, ColumnDescription column, int symbolCode, PrioSetMember.RelationToPrevMember relationToPrevMember)
           
 PrioSetMember PrioSet.addPrioSetMember(SymbolTable table, ColumnDescription column, String symbolString, PrioSetMember.RelationToPrevMember relationToPrevMember)
           
 Direction HeadRules.getDefaultDirection(NonTerminalNode nt)
           
 PhraseStructureNode HeadRules.getHeadChild(NonTerminalNode nt)
           
 PhraseStructureNode HeadRule.getHeadChild(NonTerminalNode nt)
           
 PhraseStructureNode PrioList.getHeadChild(NonTerminalNode nt)
           
 PhraseStructureNode PrioSet.getHeadChild(NonTerminalNode nt, Direction direction)
           
 String PrioSetMember.getSymbolString()
           
 String HeadRule.getSymbolString()
           
 void PrioSet.init(String setSpec)
           
 void HeadRule.init(String ruleSpec)
           
 void PrioList.init(String listSpec)
           
 void HeadRules.parseHeadRules(String fileName)
           
 void HeadRules.parseHeadRules(URL url)
           
 

Constructors in org.maltparser.core.syntaxgraph.headrules that throw MaltChainedException
HeadRule(HeadRules headRules, String ruleSpec)
           
HeadRules(org.apache.log4j.Logger logger, DataFormatInstance dataFormatInstance)
           
PrioList(HeadRule headRule, String listSpec)
           
PrioSet(PrioList prioList, String setSpec)
           
PrioSetMember(PrioSet prioSet, SymbolTable table, ColumnDescription column, String symbolString, PrioSetMember.RelationToPrevMember relationToPrevMember)
           
 

Uses of MaltChainedException in org.maltparser.core.syntaxgraph.node
 

Methods in org.maltparser.core.syntaxgraph.node that throw MaltChainedException
 void Root.addHeadEdgeLabel(LabelSet labelSet)
           
 void DependencyNode.addHeadEdgeLabel(LabelSet labelSet)
           
 void Token.addHeadEdgeLabel(LabelSet labelSet)
           
 void Root.addHeadEdgeLabel(SymbolTable table, int code)
           
 void DependencyNode.addHeadEdgeLabel(SymbolTable table, int code)
           
 void Token.addHeadEdgeLabel(SymbolTable table, int code)
           
 void Root.addHeadEdgeLabel(SymbolTable table, String symbol)
           
 void DependencyNode.addHeadEdgeLabel(SymbolTable table, String symbol)
           
 void Token.addHeadEdgeLabel(SymbolTable table, String symbol)
           
 void Root.addIncomingEdge(Edge in)
           
 void NonTerminal.addIncomingEdge(Edge in)
           
 void Node.addIncomingEdge(Edge in)
           
 void Token.addIncomingEdge(Edge in)
           
 void GraphNode.addIncomingEdge(Edge in)
           
 void Root.addOutgoingEdge(Edge out)
           
 void NonTerminal.addOutgoingEdge(Edge out)
           
 void Node.addOutgoingEdge(Edge out)
           
 void Token.addOutgoingEdge(Edge out)
           
 void GraphNode.addOutgoingEdge(Edge out)
           
 void Root.clear()
           
 void NonTerminal.clear()
           
 void Token.clear()
           
 void GraphNode.clear()
           
 DependencyNode Root.getAncestor()
           
 DependencyNode DependencyNode.getAncestor()
           
 DependencyNode Token.getAncestor()
           
 int Root.getDependencyNodeDepth()
           
 int DependencyNode.getDependencyNodeDepth()
          Returns the depth of the node.
 int Token.getDependencyNodeDepth()
           
 DependencyNode Root.getHead()
           
 DependencyNode DependencyNode.getHead()
          Returns the head dependency node if it exists, otherwise null.
 DependencyNode Token.getHead()
           
 PhraseStructureNode NonTerminalNode.getHeadChild()
           
 PhraseStructureNode Root.getHeadChild()
           
 PhraseStructureNode NonTerminal.getHeadChild()
           
 PhraseStructureNode NonTerminalNode.getHeadChild(HeadRules headRules)
           
 PhraseStructureNode Root.getHeadChild(HeadRules headRules)
           
 PhraseStructureNode NonTerminal.getHeadChild(HeadRules headRules)
           
 Edge Root.getHeadEdge()
           
 Edge DependencyNode.getHeadEdge()
          Returns the edge between the head and the node if it exists, otherwise null.
 Edge Token.getHeadEdge()
           
 int Root.getHeadEdgeLabelCode(SymbolTable table)
           
 int DependencyNode.getHeadEdgeLabelCode(SymbolTable table)
           
 int Token.getHeadEdgeLabelCode(SymbolTable table)
           
 LabelSet Root.getHeadEdgeLabelSet()
           
 LabelSet DependencyNode.getHeadEdgeLabelSet()
           
 LabelSet Token.getHeadEdgeLabelSet()
           
 String Root.getHeadEdgeLabelSymbol(SymbolTable table)
           
 String DependencyNode.getHeadEdgeLabelSymbol(SymbolTable table)
           
 String Token.getHeadEdgeLabelSymbol(SymbolTable table)
           
 Set<SymbolTable> Root.getHeadEdgeLabelTypes()
           
 Set<SymbolTable> DependencyNode.getHeadEdgeLabelTypes()
           
 Set<SymbolTable> Token.getHeadEdgeLabelTypes()
           
 Set<Edge> Root.getHeadEdges()
           
 Set<Edge> DependencyNode.getHeadEdges()
           
 Set<Edge> Token.getHeadEdges()
           
 Set<DependencyNode> Root.getHeads()
           
 Set<DependencyNode> DependencyNode.getHeads()
           
 Set<DependencyNode> Token.getHeads()
           
 ComparableNode ComparableNode.getLeftmostDescendant()
          Returns the left-most terminal descendant node.
 ComparableNode Root.getLeftmostDescendant()
           
 ComparableNode NonTerminal.getLeftmostDescendant()
           
 ComparableNode Token.getLeftmostDescendant()
           
 int ComparableNode.getLeftmostDescendantIndex()
          Returns the index of the left-most terminal descendant node.
 int GraphNode.getLeftmostDescendantIndex()
           
 ComparableNode ComparableNode.getLeftmostProperDescendant()
          Returns the left-most proper terminal descendant node (excluding itself).
 ComparableNode Root.getLeftmostProperDescendant()
           
 ComparableNode Token.getLeftmostProperDescendant()
           
 int ComparableNode.getLeftmostProperDescendantIndex()
          Returns the index of the left-most proper terminal descendant node (excluding itself).
 int GraphNode.getLeftmostProperDescendantIndex()
           
 DependencyNode Root.getLeftSibling()
          Returns the left sibling if it exists, otherwise null
 DependencyNode DependencyNode.getLeftSibling()
          Returns the left sibling if it exists, otherwise null
 DependencyNode Token.getLeftSibling()
          Returns the left sibling if it exists, otherwise null
 TokenNode NonTerminalNode.getLexicalHead()
           
 TokenNode Root.getLexicalHead()
           
 TokenNode NonTerminal.getLexicalHead()
           
 TokenNode NonTerminalNode.getLexicalHead(HeadRules headRules)
           
 TokenNode Root.getLexicalHead(HeadRules headRules)
           
 TokenNode NonTerminal.getLexicalHead(HeadRules headRules)
           
 Edge PhraseStructureNode.getParentEdge()
           
 Edge Root.getParentEdge()
           
 Edge NonTerminal.getParentEdge()
           
 Edge Token.getParentEdge()
           
 int PhraseStructureNode.getParentEdgeLabelCode(SymbolTable table)
           
 int Root.getParentEdgeLabelCode(SymbolTable table)
           
 int NonTerminal.getParentEdgeLabelCode(SymbolTable table)
           
 int Token.getParentEdgeLabelCode(SymbolTable table)
           
 String PhraseStructureNode.getParentEdgeLabelSymbol(SymbolTable table)
           
 String Root.getParentEdgeLabelSymbol(SymbolTable table)
           
 String NonTerminal.getParentEdgeLabelSymbol(SymbolTable table)
           
 String Token.getParentEdgeLabelSymbol(SymbolTable table)
           
 DependencyNode Root.getProperAncestor()
           
 DependencyNode DependencyNode.getProperAncestor()
           
 DependencyNode Token.getProperAncestor()
           
 ComparableNode ComparableNode.getRightmostDescendant()
          Returns the right-most terminal descendant node.
 ComparableNode Root.getRightmostDescendant()
           
 ComparableNode NonTerminal.getRightmostDescendant()
           
 ComparableNode Token.getRightmostDescendant()
           
 int ComparableNode.getRightmostDescendantIndex()
          Returns the index of the right-most terminal descendant node.
 int GraphNode.getRightmostDescendantIndex()
           
 ComparableNode ComparableNode.getRightmostProperDescendant()
          Returns the right-most proper terminal descendant node (excluding itself).
 ComparableNode Root.getRightmostProperDescendant()
           
 ComparableNode Token.getRightmostProperDescendant()
           
 int ComparableNode.getRightmostProperDescendantIndex()
          Returns the index of the right-most proper terminal descendant node (excluding itself).
 int GraphNode.getRightmostProperDescendantIndex()
           
 DependencyNode Root.getRightSibling()
          Returns the right sibling if it exists, otherwise null
 DependencyNode DependencyNode.getRightSibling()
          Returns the right sibling if it exists, otherwise null
 DependencyNode Token.getRightSibling()
          Returns the right sibling if it exists, otherwise null
 DependencyNode Root.getSameSideLeftSibling()
          Returns the left sibling at the same side of head as the node it self.
 DependencyNode DependencyNode.getSameSideLeftSibling()
          Returns the left sibling at the same side of head as the node it self.
 DependencyNode Token.getSameSideLeftSibling()
          Returns the left sibling at the same side of head as the node it self.
 DependencyNode Root.getSameSideRightSibling()
          Returns the right sibling at the same side of head as the node it self.
 DependencyNode DependencyNode.getSameSideRightSibling()
          Returns the right sibling at the same side of head as the node it self.
 DependencyNode Token.getSameSideRightSibling()
          Returns the right sibling at the same side of head as the node it self.
 boolean Root.hasAncestorInside(int left, int right)
           
 boolean DependencyNode.hasAncestorInside(int left, int right)
           
 boolean Token.hasAncestorInside(int left, int right)
           
 boolean Root.hasHeadEdgeLabel(SymbolTable table)
           
 boolean DependencyNode.hasHeadEdgeLabel(SymbolTable table)
           
 boolean Token.hasHeadEdgeLabel(SymbolTable table)
           
 boolean PhraseStructureNode.hasParentEdgeLabel(SymbolTable table)
           
 boolean Root.hasParentEdgeLabel(SymbolTable table)
           
 boolean NonTerminal.hasParentEdgeLabel(SymbolTable table)
           
 boolean Token.hasParentEdgeLabel(SymbolTable table)
           
 TokenNode NonTerminalNode.identifyHead(HeadRules headRules)
           
 TokenNode Root.identifyHead(HeadRules headRules)
           
 TokenNode NonTerminal.identifyHead(HeadRules headRules)
           
 boolean Root.isHeadEdgeLabeled()
           
 boolean DependencyNode.isHeadEdgeLabeled()
           
 boolean Token.isHeadEdgeLabeled()
           
 boolean Root.isProjective()
           
 boolean DependencyNode.isProjective()
          Returns true if the head edge is projective, otherwise false.
 boolean Token.isProjective()
           
 int Root.nHeadEdgeLabels()
           
 int DependencyNode.nHeadEdgeLabels()
           
 int Token.nHeadEdgeLabels()
           
 void NonTerminal.removeIncomingEdge(Edge in)
           
 void Node.removeIncomingEdge(Edge in)
           
 void Token.removeIncomingEdge(Edge in)
           
 void GraphNode.removeIncomingEdge(Edge in)
           
 void Root.removeOutgoingEdge(Edge out)
           
 void NonTerminal.removeOutgoingEdge(Edge out)
           
 void Node.removeOutgoingEdge(Edge out)
           
 void Token.removeOutgoingEdge(Edge out)
           
 void GraphNode.removeOutgoingEdge(Edge out)
           
 void Root.setIndex(int index)
           
 void NonTerminal.setIndex(int index)
           
 void Node.setIndex(int index)
           
 void Token.setIndex(int index)
           
abstract  void GraphNode.setIndex(int index)
           
 

Constructors in org.maltparser.core.syntaxgraph.node that throw MaltChainedException
GraphNode()
           
NonTerminal()
           
Root()
           
Token()
           
 

Uses of MaltChainedException in org.maltparser.core.syntaxgraph.reader
 

Methods in org.maltparser.core.syntaxgraph.reader that throw MaltChainedException
 void TabReader.clear()
           
 void TigerXMLReader.close()
           
 void SyntaxGraphReader.close()
          Closes the file or the input stream.
 void NegraReader.close()
           
 void TabReader.close()
           
 void BracketReader.close()
           
 int SyntaxGraphReader.getSentenceCount()
          Returns the current number of the sentence.
 int TabReader.getSentenceCount()
           
 int BracketReader.getSentenceCount()
           
 void ReadChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
           
 void ReadChartItem.initInput(String nullValueStategy)
           
 void ReadChartItem.initReader(Class<? extends SyntaxGraphReader> syntaxGraphReader, String inputFile, String inputCharSet, String readerOptions, int iterations)
           
 void TigerXMLReader.open(InputStream is, String charsetName)
           
 void SyntaxGraphReader.open(InputStream is, String charsetName)
          Opens an input stream
 void NegraReader.open(InputStream is, String charsetName)
           
 void TabReader.open(InputStream is, String charsetName)
           
 void BracketReader.open(InputStream is, String charsetName)
           
 void TigerXMLReader.open(String fileName, String charsetName)
           
 void SyntaxGraphReader.open(String fileName, String charsetName)
          Opens a file for read only
 void NegraReader.open(String fileName, String charsetName)
           
 void TabReader.open(String fileName, String charsetName)
           
 void BracketReader.open(String fileName, String charsetName)
           
 void TigerXMLReader.open(URL url, String charsetName)
           
 void SyntaxGraphReader.open(URL url, String charsetName)
          Opens an URL for read only
 void NegraReader.open(URL url, String charsetName)
           
 void TabReader.open(URL url, String charsetName)
           
 void BracketReader.open(URL url, String charsetName)
           
 int ReadChartItem.postprocess(int signal)
           
 int ReadChartItem.preprocess(int signal)
           
 int ReadChartItem.process(int signal)
           
 void TigerXMLReader.readEpilog()
           
 void SyntaxGraphReader.readEpilog()
          Reads the end of the file, after all sentences have been processed,
 void NegraReader.readEpilog()
           
 void TabReader.readEpilog()
           
 void BracketReader.readEpilog()
           
 void TigerXMLReader.readProlog()
           
 void SyntaxGraphReader.readProlog()
          Cause the syntax graph reader to read the beginning of the file (such as header information)
 void NegraReader.readProlog()
           
 void TabReader.readProlog()
           
 void BracketReader.readProlog()
           
 boolean TigerXMLReader.readSentence(TokenStructure syntaxGraph)
           
 boolean SyntaxGraphReader.readSentence(TokenStructure syntaxGraph)
          Reads a sentence (token structure, dependency structure or/and phrase structure)
 boolean NegraReader.readSentence(TokenStructure syntaxGraph)
           
 boolean TabReader.readSentence(TokenStructure syntaxGraph)
           
 boolean BracketReader.readSentence(TokenStructure syntaxGraph)
           
 void TigerXMLReader.setOptions(String optionString)
           
 void SyntaxGraphReader.setOptions(String optionString)
          Sets the reader specific options.
 void NegraReader.setOptions(String optionString)
           
 void TabReader.setOptions(String optionString)
           
 void BracketReader.setOptions(String optionString)
           
 void TabReader.setReader(BufferedReader reader)
           
 void ReadChartItem.setSyntaxGraphReaderClass(Class<?> graphReaderClass)
           
 void ReadChartItem.terminate()
           
 

Uses of MaltChainedException in org.maltparser.core.syntaxgraph.writer
 

Methods in org.maltparser.core.syntaxgraph.writer that throw MaltChainedException
 void TabWriter.close()
           
 void BracketWriter.close()
           
 void NegraWriter.close()
           
 void SyntaxGraphWriter.close()
          Closes the file or the output stream.
 void TigerXMLWriter.close()
           
 void WriteChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
           
 void WriteChartItem.initOutput(String nullValueStategy)
           
 void WriteChartItem.initWriter(Class<? extends SyntaxGraphWriter> syntaxGraphWriterClass, String outputFile, String outputCharSet, String writerOption)
           
 void TabWriter.open(OutputStream os, String charsetName)
           
 void BracketWriter.open(OutputStream os, String charsetName)
           
 void NegraWriter.open(OutputStream os, String charsetName)
           
 void SyntaxGraphWriter.open(OutputStream os, String charsetName)
          Opens an output stream
 void TigerXMLWriter.open(OutputStream os, String charsetName)
           
 void TabWriter.open(String fileName, String charsetName)
           
 void BracketWriter.open(String fileName, String charsetName)
           
 void NegraWriter.open(String fileName, String charsetName)
           
 void SyntaxGraphWriter.open(String fileName, String charsetName)
          Opens a file for writing
 void TigerXMLWriter.open(String fileName, String charsetName)
           
 int WriteChartItem.postprocess(int signal)
           
 int WriteChartItem.preprocess(int signal)
           
 int WriteChartItem.process(int signal)
           
 void TabWriter.setOptions(String optionString)
           
 void BracketWriter.setOptions(String optionString)
           
 void NegraWriter.setOptions(String optionString)
           
 void SyntaxGraphWriter.setOptions(String optionString)
          Sets the writer specific options.
 void TigerXMLWriter.setOptions(String optionString)
           
 void WriteChartItem.setSyntaxGraphWriterClass(Class<?> graphWriterClass)
           
 void TabWriter.setWriter(BufferedWriter writer)
           
 void BracketWriter.setWriter(BufferedWriter writer)
           
 void WriteChartItem.terminate()
           
 void TabWriter.writeEpilog()
           
 void BracketWriter.writeEpilog()
           
 void NegraWriter.writeEpilog()
           
 void SyntaxGraphWriter.writeEpilog()
          Writes the end of the file
 void TigerXMLWriter.writeEpilog()
           
 void TigerXMLWriter.writeNonTerminal(NonTerminalNode nt, String id)
           
 void TigerXMLWriter.writeNonTerminals(PhraseStructure phraseStructure)
           
 void TabWriter.writeProlog()
           
 void BracketWriter.writeProlog()
           
 void NegraWriter.writeProlog()
           
 void SyntaxGraphWriter.writeProlog()
          Cause the syntax graph writer to write the beginning of the file (such as header information)
 void TigerXMLWriter.writeProlog()
           
 void TabWriter.writeSentence(TokenStructure syntaxGraph)
           
 void BracketWriter.writeSentence(TokenStructure syntaxGraph)
           
 void NegraWriter.writeSentence(TokenStructure syntaxGraph)
           
 void SyntaxGraphWriter.writeSentence(TokenStructure syntaxGraph)
          Writes a sentence (token structure, dependency structure or/and phrase structure)
 void TigerXMLWriter.writeSentence(TokenStructure syntaxGraph)
           
 

Uses of MaltChainedException in org.maltparser.ml
 

Methods in org.maltparser.ml that throw MaltChainedException
 void LearningMethod.addInstance(SingleDecision decision, FeatureVector featureVector)
           
 void LearningMethod.finalizeSentence(DependencyStructure dependencyGraph)
           
 void LearningMethod.moveAllInstances(LearningMethod method, FeatureFunction divideFeature, ArrayList<Integer> divideFeatureIndexVector)
           
 void LearningMethod.noMoreInstances()
           
 boolean LearningMethod.predict(FeatureVector features, SingleDecision decision)
           
 void LearningMethod.terminate()
           
 void LearningMethod.train(FeatureVector featureVector)
           
 

Uses of MaltChainedException in org.maltparser.ml.lib
 

Subclasses of MaltChainedException in org.maltparser.ml.lib
 class LibException
          LibException extends the MaltChainedException class and is thrown by classes within the lib package.
 

Methods in org.maltparser.ml.lib that throw MaltChainedException
 void Lib.addInstance(SingleDecision decision, FeatureVector featureVector)
           
protected  int Lib.binariesInstance(String line, FeatureList featureList)
           
protected  void Lib.binariesInstances2SVMFileFormat(InputStreamReader isr, OutputStreamWriter osw)
           
protected  void Lib.closeInstanceWriter()
           
 void Lib.finalizeSentence(DependencyStructure dependencyGraph)
           
protected  JarEntry Lib.getConfigFileEntry(String suffix)
           
 DependencyParserConfig Lib.getConfiguration()
          Returns the current configuration
protected  File Lib.getFile(String suffix)
           
protected  InputStream Lib.getInputStreamFromConfigFileEntry(String suffix)
           
protected  InputStreamReader Lib.getInstanceInputStreamReader(String suffix)
           
protected  InputStreamReader Lib.getInstanceInputStreamReaderFromConfigFile(String suffix)
           
protected  OutputStreamWriter Lib.getInstanceOutputStreamWriter(String suffix)
           
 int Lib.getNumberOfInstances()
           
protected  void Lib.initSpecialParameters()
           
protected  FeatureMap Lib.loadFeatureMap(InputStream is)
           
 void Lib.moveAllInstances(LearningMethod method, FeatureFunction divideFeature, ArrayList<Integer> divideFeatureIndexVector)
           
 void Lib.noMoreInstances()
           
 void Lib.parseParameters(String paramstring)
           
 boolean Lib.predict(FeatureVector featureVector, SingleDecision decision)
           
protected  void Lib.saveFeatureMap(OutputStream os, FeatureMap map)
           
 void Lib.setLearnerMode(int learnerMode)
           
 void LibSvm.terminate()
           
 void Lib.terminate()
           
 void LibLinear.terminate()
           
 void Lib.train(FeatureVector featureVector)
           
protected  void LibSvm.trainExternal(FeatureVector featureVector)
           
protected abstract  void Lib.trainExternal(FeatureVector featureVector)
           
protected  void LibLinear.trainExternal(FeatureVector featureVector)
           
protected  void LibSvm.trainInternal(FeatureVector featureVector)
           
protected abstract  void Lib.trainInternal(FeatureVector featureVector)
           
protected  void LibLinear.trainInternal(FeatureVector featureVector)
           
 

Constructors in org.maltparser.ml.lib that throw MaltChainedException
Lib(InstanceModel owner, Integer learnerMode, String learningMethodName)
          Constructs a Lib learner.
LibLinear(InstanceModel owner, Integer learnerMode)
           
LibSvm(InstanceModel owner, Integer learnerMode)
           
 

Uses of MaltChainedException in org.maltparser.parser
 

Subclasses of MaltChainedException in org.maltparser.parser
 class ParsingException
          ParsingException extends the MaltChainedException class and is thrown by classes within the parser.algorithm package.
 

Methods in org.maltparser.parser that throw MaltChainedException
protected abstract  void TransitionSystem.addAvailableTransitionToTable(TransitionTable ttable)
           
protected  void TransitionSystem.addEdgeLabels(Edge e)
           
 void ParserState.apply(GuideUserAction currentAction)
           
abstract  void TransitionSystem.apply(GuideUserAction currentAction, ParserConfiguration config)
           
 void SingleMalt.checkOptionDependency()
           
abstract  void ParserConfiguration.clear()
          Clears the parser configuration
 void ParserState.clear()
           
 void Algorithm.closeDiaWriter()
           
 void TransitionSystem.copyAction(GuideUserAction source, GuideUserAction target)
           
protected  void Algorithm.copyDynamicInput(DependencyStructure source, DependencyStructure target)
           
protected  void Algorithm.copyEdges(DependencyStructure source, DependencyStructure target)
          Copies the edges of the source dependency structure to the target dependency structure
abstract  GuideUserAction TransitionSystem.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 String TransitionSystem.getActionString(GuideUserAction action)
           
abstract  GuideUserAction TransitionSystem.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 OptionManager SingleMalt.getOptionManager()
           
 Object SingleMalt.getOptionValue(String optiongroup, String optionname)
           
 String SingleMalt.getOptionValueString(String optiongroup, String optionname)
           
 org.apache.log4j.Logger SingleMalt.initConfigLogger(String logfile, String level)
          Initialize the configuration logger
 void ParserState.initialize(DependencyStructure dependencyStructure)
           
 void SingleMaltChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
           
 void SingleMalt.initialize(int containerIndex, DataFormatInstance dataFormatInstance, ConfigurationDir configDir, int mode)
           
abstract  void ParserConfiguration.initialize(ParserConfiguration config)
          Initialize the parser configuration with the same state as the parameter config
protected  void Algorithm.initParserState(int k)
           
protected  void SingleMalt.initParsingAlgorithm()
          Initialize the parsing algorithm
 void TransitionSystem.initTableHandlers(String decisionSettings, SymbolTableHandler symbolTableHandler)
           
 void TransitionSystem.initTransitionSystem(GuideUserHistory history)
           
protected abstract  void TransitionSystem.initWithDefaultTransitions(GuideUserHistory history)
           
abstract  boolean ParserConfiguration.isTerminalState()
          Returns true if the parser configuration is in a terminal state, otherwise false.
 boolean ParserState.isTerminalState()
           
 OracleGuide AbstractParserFactory.makeOracleGuide(GuideUserHistory history)
          Creates an oracle guide
 ParserConfiguration AbstractParserFactory.makeParserConfiguration()
          Creates a parser configuration
protected  AbstractParserFactory Algorithm.makeParserFactory()
          Creates a parser factory specified by the --singlemalt-parsing_algorithm option
 TransitionSystem AbstractParserFactory.makeTransitionSystem()
          Creates a transition system
 int ParserState.nConfigurations()
           
 void Algorithm.openDiaWriter(String fileName)
           
 void SingleMalt.oracleParse(DependencyStructure goldGraph, DependencyStructure oracleGraph)
           
 void DependencyParserConfig.oracleParse(DependencyStructure goldGraph, DependencyStructure oracleGraph)
           
 void SingleMalt.parse(DependencyStructure graph)
           
 void DependencyParserConfig.parse(DependencyStructure graph)
           
abstract  DependencyStructure Parser.parse(DependencyStructure parseDependencyGraph)
          Parses the empty dependency graph
 DependencyStructure DeterministicParser.parse(DependencyStructure parseDependencyGraph)
           
 DependencyStructure BatchTrainer.parse(DependencyStructure goldDependencyGraph, DependencyStructure parseDependencyGraph)
           
abstract  DependencyStructure Trainer.parse(DependencyStructure goldDependencyGraph, DependencyStructure parseDependencyGraph)
          Trains a parser using the gold-standard dependency graph and returns a parsed dependency graph
 boolean ParserState.permissible(GuideUserAction currentAction)
           
abstract  boolean TransitionSystem.permissible(GuideUserAction currentAction, ParserConfiguration config)
           
 int SingleMaltChartItem.postprocess(int signal)
           
 int SingleMaltChartItem.preprocess(int signal)
           
 int SingleMaltChartItem.process(int signal)
           
 void SingleMalt.process(Object[] arguments)
           
abstract  void ParserConfiguration.setDependencyGraph(DependencyStructure dependencyStructure)
          Sets the dependency structure
 void BatchTrainer.terminate()
           
 void DeterministicParser.terminate()
           
abstract  void Algorithm.terminate()
           
 void SingleMaltChartItem.terminate()
           
 void SingleMalt.terminate(Object[] arguments)
           
 void SingleMalt.train()
           
 void BatchTrainer.train()
           
abstract  void Trainer.train()
           
protected  GuideUserAction TransitionSystem.updateActionContainers(GuideUserHistory history, int transition, LabelSet arcLabels)
           
protected  GuideUserAction Oracle.updateActionContainers(int transition, LabelSet arcLabels)
           
 void Algorithm.writeToDiaFile(String message)
           
 

Constructors in org.maltparser.parser that throw MaltChainedException
Algorithm(DependencyParserConfig manager)
          Creates a parsing algorithm
BatchTrainer(DependencyParserConfig manager)
           
DeterministicParser(DependencyParserConfig manager)
           
Oracle(DependencyParserConfig manager, GuideUserHistory history)
           
Parser(DependencyParserConfig manager)
          Creates a parser
ParserState(Algorithm algorithm, AbstractParserFactory factory)
           
ParserState(Algorithm algorithm, AbstractParserFactory factory, int k)
           
Trainer(DependencyParserConfig manager)
          Creates a parser trainer
TransitionSystem()
           
 

Uses of MaltChainedException in org.maltparser.parser.algorithm.covington
 

Methods in org.maltparser.parser.algorithm.covington that throw MaltChainedException
protected  void Projective.addAvailableTransitionToTable(TransitionTable ttable)
           
protected  void NonProjective.addAvailableTransitionToTable(TransitionTable ttable)
           
 void Projective.apply(GuideUserAction currentAction, ParserConfiguration config)
           
 void NonProjective.apply(GuideUserAction currentAction, ParserConfiguration config)
           
 void CovingtonConfig.clear()
           
 GuideUserAction Projective.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 GuideUserAction NonProjective.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 void CovingtonOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 GuideUserAction Projective.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 GuideUserAction NonProjective.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 DependencyNode CovingtonConfig.getLeftContextNode(int index)
           
 DependencyNode CovingtonConfig.getLeftNode(int index)
           
 DependencyNode CovingtonConfig.getRightContextNode(int index)
           
 DependencyNode CovingtonConfig.getRightNode(int index)
           
 void CovingtonAddressFunction.initialize(Object[] arguments)
           
 void CovingtonConfig.initialize(ParserConfiguration parserConfiguration)
           
protected  void Projective.initWithDefaultTransitions(GuideUserHistory history)
           
protected  void NonProjective.initWithDefaultTransitions(GuideUserHistory history)
           
 Function CovingtonFactory.makeFunction(String subFunctionName)
           
 OracleGuide CovingtonNonProjFactory.makeOracleGuide(GuideUserHistory history)
           
 OracleGuide CovingtonProjFactory.makeOracleGuide(GuideUserHistory history)
           
 ParserConfiguration CovingtonFactory.makeParserConfiguration()
           
 TransitionSystem CovingtonNonProjFactory.makeTransitionSystem()
           
 TransitionSystem CovingtonProjFactory.makeTransitionSystem()
           
 boolean Projective.permissible(GuideUserAction currentAction, ParserConfiguration config)
           
 boolean NonProjective.permissible(GuideUserAction currentAction, ParserConfiguration config)
           
 GuideUserAction CovingtonOracle.predict(DependencyStructure gold, ParserConfiguration config)
           
 void CovingtonConfig.setDependencyGraph(DependencyStructure source)
           
 void CovingtonOracle.terminate()
           
 void CovingtonAddressFunction.update()
           
 void CovingtonAddressFunction.update(Object[] arguments)
           
 

Constructors in org.maltparser.parser.algorithm.covington that throw MaltChainedException
CovingtonConfig(SymbolTableHandler symbolTableHandler, boolean cr, boolean cs)
           
CovingtonOracle(DependencyParserConfig manager, GuideUserHistory history)
           
NonProjective()
           
Projective()
           
 

Uses of MaltChainedException in org.maltparser.parser.algorithm.nivre
 

Methods in org.maltparser.parser.algorithm.nivre that throw MaltChainedException
protected  void ArcStandard.addAvailableTransitionToTable(TransitionTable ttable)
           
protected  void ArcEager.addAvailableTransitionToTable(TransitionTable ttable)
           
 void ArcStandard.apply(GuideUserAction currentAction, ParserConfiguration config)
           
 void ArcEager.apply(GuideUserAction currentAction, ParserConfiguration config)
           
 void NivreConfig.clear()
           
 GuideUserAction ArcStandard.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 GuideUserAction ArcEager.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 void ArcEagerOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 void ArcStandardOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 GuideUserAction ArcStandard.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 GuideUserAction ArcEager.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 DependencyNode NivreConfig.getInputNode(int index)
           
 DependencyNode NivreConfig.getStackNode(int index)
           
 void NivreAddressFunction.initialize(Object[] arguments)
           
 void NivreConfig.initialize(ParserConfiguration parserConfiguration)
           
protected  void ArcStandard.initWithDefaultTransitions(GuideUserHistory history)
           
protected  void ArcEager.initWithDefaultTransitions(GuideUserHistory history)
           
 Function NivreFactory.makeFunction(String subFunctionName)
           
 OracleGuide NivreArcEagerFactory.makeOracleGuide(GuideUserHistory history)
           
 OracleGuide NivreArcStandardFactory.makeOracleGuide(GuideUserHistory history)
           
 ParserConfiguration NivreFactory.makeParserConfiguration()
           
 TransitionSystem NivreArcEagerFactory.makeTransitionSystem()
           
 TransitionSystem NivreArcStandardFactory.makeTransitionSystem()
           
 boolean ArcStandard.permissible(GuideUserAction currentAction, ParserConfiguration config)
           
 boolean ArcEager.permissible(GuideUserAction currentAction, ParserConfiguration config)
           
 GuideUserAction ArcEagerOracle.predict(DependencyStructure gold, ParserConfiguration config)
           
 GuideUserAction ArcStandardOracle.predict(DependencyStructure gold, ParserConfiguration config)
           
 void NivreConfig.setDependencyGraph(DependencyStructure source)
           
protected  void NivreConfig.setRootHandling(String rh)
           
 void ArcEagerOracle.terminate()
           
 void ArcStandardOracle.terminate()
           
 void NivreAddressFunction.update()
           
 void NivreAddressFunction.update(Object[] arguments)
           
 

Constructors in org.maltparser.parser.algorithm.nivre that throw MaltChainedException
ArcEager()
           
ArcEagerOracle(DependencyParserConfig manager, GuideUserHistory history)
           
ArcStandard()
           
ArcStandardOracle(DependencyParserConfig manager, GuideUserHistory history)
           
NivreConfig(SymbolTableHandler symbolTableHandler, String rootHandling)
           
 

Uses of MaltChainedException in org.maltparser.parser.algorithm.planar
 

Methods in org.maltparser.parser.algorithm.planar that throw MaltChainedException
protected  void Planar.addAvailableTransitionToTable(TransitionTable ttable)
           
 void Planar.apply(GuideUserAction currentAction, ParserConfiguration config)
           
 void PlanarConfig.clear()
           
 GuideUserAction Planar.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 void PlanarArcEagerOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 GuideUserAction Planar.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 DependencyNode PlanarConfig.getInputNode(int index)
           
 DependencyNode PlanarConfig.getStackNode(int index)
           
 void PlanarAddressFunction.initialize(Object[] arguments)
           
 void PlanarConfig.initialize(ParserConfiguration parserConfiguration)
           
protected  void Planar.initWithDefaultTransitions(GuideUserHistory history)
           
 Function PlanarFactory.makeFunction(String subFunctionName)
           
 OracleGuide NivrePlanarArcEagerFactory.makeOracleGuide(GuideUserHistory history)
           
 ParserConfiguration PlanarFactory.makeParserConfiguration()
           
 TransitionSystem NivrePlanarArcEagerFactory.makeTransitionSystem()
           
 boolean Planar.permissible(GuideUserAction currentAction, ParserConfiguration config)
           
 GuideUserAction PlanarArcEagerOracle.predict(DependencyStructure gold, ParserConfiguration config)
           
protected  void PlanarConfig.setConnectedness(String conn)
           
 void PlanarConfig.setDependencyGraph(DependencyStructure source)
           
 void PlanarArcEagerOracle.terminate()
           
 void PlanarAddressFunction.update()
           
 void PlanarAddressFunction.update(Object[] arguments)
           
 

Constructors in org.maltparser.parser.algorithm.planar that throw MaltChainedException
Planar()
           
PlanarArcEagerOracle(DependencyParserConfig manager, GuideUserHistory history)
           
PlanarConfig(SymbolTableHandler symbolTableHandler, String noCoveredRoots, String acyclicity, String connectedness)
           
 

Uses of MaltChainedException in org.maltparser.parser.algorithm.stack
 

Methods in org.maltparser.parser.algorithm.stack that throw MaltChainedException
protected  void Projective.addAvailableTransitionToTable(TransitionTable ttable)
           
protected  void NonProjective.addAvailableTransitionToTable(TransitionTable ttable)
           
 void Projective.apply(GuideUserAction currentAction, ParserConfiguration configuration)
           
 void NonProjective.apply(GuideUserAction currentAction, ParserConfiguration configuration)
           
 void StackConfig.clear()
           
 GuideUserAction Projective.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 GuideUserAction NonProjective.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 void SwapLazyOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 void ProjectiveOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 void SwapEagerOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 GuideUserAction Projective.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 GuideUserAction NonProjective.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 DependencyNode StackConfig.getInputNode(int index)
           
 DependencyNode StackConfig.getLookaheadNode(int index)
           
 DependencyNode StackConfig.getStackNode(int index)
           
 void StackAddressFunction.initialize(Object[] arguments)
           
 void StackConfig.initialize(ParserConfiguration parserConfiguration)
           
protected  void Projective.initWithDefaultTransitions(GuideUserHistory history)
           
protected  void NonProjective.initWithDefaultTransitions(GuideUserHistory history)
           
 Function StackFactory.makeFunction(String subFunctionName)
           
 OracleGuide StackSwapLazyFactory.makeOracleGuide(GuideUserHistory history)
           
 OracleGuide StackProjFactory.makeOracleGuide(GuideUserHistory history)
           
 OracleGuide StackSwapEagerFactory.makeOracleGuide(GuideUserHistory history)
           
 ParserConfiguration StackFactory.makeParserConfiguration()
           
 TransitionSystem StackSwapLazyFactory.makeTransitionSystem()
           
 TransitionSystem StackProjFactory.makeTransitionSystem()
           
 TransitionSystem StackSwapEagerFactory.makeTransitionSystem()
           
 boolean Projective.permissible(GuideUserAction currentAction, ParserConfiguration configuration)
           
 boolean NonProjective.permissible(GuideUserAction currentAction, ParserConfiguration configuration)
           
 GuideUserAction SwapLazyOracle.predict(DependencyStructure gold, ParserConfiguration configuration)
           
 GuideUserAction ProjectiveOracle.predict(DependencyStructure gold, ParserConfiguration configuration)
           
 GuideUserAction SwapEagerOracle.predict(DependencyStructure gold, ParserConfiguration configuration)
           
 void StackConfig.setDependencyGraph(DependencyStructure source)
           
 void SwapLazyOracle.terminate()
           
 void ProjectiveOracle.terminate()
           
 void SwapEagerOracle.terminate()
           
 void StackAddressFunction.update()
           
 void StackAddressFunction.update(Object[] arguments)
           
 

Constructors in org.maltparser.parser.algorithm.stack that throw MaltChainedException
NonProjective()
           
Projective()
           
ProjectiveOracle(DependencyParserConfig manager, GuideUserHistory history)
           
StackConfig(SymbolTableHandler symbolTableHandler)
           
SwapEagerOracle(DependencyParserConfig manager, GuideUserHistory history)
           
SwapLazyOracle(DependencyParserConfig manager, GuideUserHistory history)
           
 

Uses of MaltChainedException in org.maltparser.parser.algorithm.twoplanar
 

Methods in org.maltparser.parser.algorithm.twoplanar that throw MaltChainedException
protected  void TwoPlanar.addAvailableTransitionToTable(TransitionTable ttable)
           
 void TwoPlanar.apply(GuideUserAction currentAction, ParserConfiguration config)
           
 void TwoPlanarConfig.clear()
           
 GuideUserAction TwoPlanar.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 void TwoPlanarArcEagerOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 DependencyNode TwoPlanarConfig.getActiveStackNode(int index)
           
 GuideUserAction TwoPlanar.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 DependencyNode TwoPlanarConfig.getInactiveStackNode(int index)
           
 DependencyNode TwoPlanarConfig.getInputNode(int index)
           
 void TwoPlanarAddressFunction.initialize(Object[] arguments)
           
 void TwoPlanarConfig.initialize(ParserConfiguration parserConfiguration)
           
protected  void TwoPlanar.initWithDefaultTransitions(GuideUserHistory history)
           
 Function TwoPlanarFactory.makeFunction(String subFunctionName)
           
 OracleGuide TwoPlanarArcEagerFactory.makeOracleGuide(GuideUserHistory history)
           
 ParserConfiguration TwoPlanarFactory.makeParserConfiguration()
           
 TransitionSystem TwoPlanarArcEagerFactory.makeTransitionSystem()
           
 boolean TwoPlanar.permissible(GuideUserAction currentAction, ParserConfiguration config)
           
 GuideUserAction TwoPlanarArcEagerOracle.predict(DependencyStructure gold, ParserConfiguration config)
           
 void TwoPlanarConfig.setDependencyGraph(DependencyStructure source)
           
protected  void TwoPlanarConfig.setRootHandling(String rh)
           
 void TwoPlanarArcEagerOracle.terminate()
           
 void TwoPlanarAddressFunction.update()
           
 void TwoPlanarAddressFunction.update(Object[] arguments)
           
 

Constructors in org.maltparser.parser.algorithm.twoplanar that throw MaltChainedException
TwoPlanar()
           
TwoPlanarArcEagerOracle(DependencyParserConfig manager, GuideUserHistory history)
           
TwoPlanarConfig(SymbolTableHandler symbolTableHandler, String noCoveredRoots, String acyclicity, String reduceAfterSwitch, String rootHandling)
           
 

Uses of MaltChainedException in org.maltparser.parser.guide
 

Subclasses of MaltChainedException in org.maltparser.parser.guide
 class GuideException
          GuideException extends the MaltChainedException class and is thrown by classes within the guide package.
 

Methods in org.maltparser.parser.guide that throw MaltChainedException
 void ClassifierGuide.addInstance(GuideDecision decision)
           
 void SingleGuide.addInstance(GuideDecision decision)
           
 FeatureVector ClassifierGuide.extract()
           
 FeatureVector SingleGuide.extract()
           
 void Guide.finalizeSentence(DependencyStructure dependencyGraph)
           
 void SingleGuide.finalizeSentence(DependencyStructure dependencyGraph)
           
 void Model.finalizeSentence(DependencyStructure dependencyGraph)
           
 String Model.getModelName()
           
protected  void SingleGuide.initDecisionModel(SingleDecision decision)
           
 void ClassifierGuide.noMoreInstances()
           
 void SingleGuide.noMoreInstances()
           
 void Model.noMoreInstances()
           
 GuideUserAction OracleGuide.predict(DependencyStructure gold, ParserConfiguration config)
           
 void ClassifierGuide.predict(GuideDecision decision)
           
 void SingleGuide.predict(GuideDecision decision)
           
 void Guidable.predict(GuideUserAction action)
           
 FeatureVector ClassifierGuide.predictExtract(GuideDecision decision)
           
 FeatureVector SingleGuide.predictExtract(GuideDecision decision)
           
 boolean ClassifierGuide.predictFromKBestList(GuideDecision decision)
           
 boolean SingleGuide.predictFromKBestList(GuideDecision decision)
           
 boolean Guidable.predictFromKBestList(GuideUserAction action)
           
 void Guidable.setInstance(GuideUserAction action)
           
 void Guide.terminate()
           
 void SingleGuide.terminate()
           
 void Model.terminate()
           
 

Constructors in org.maltparser.parser.guide that throw MaltChainedException
SingleGuide(DependencyParserConfig configuration, GuideHistory history, ClassifierGuide.GuideMode guideMode)
           
 

Uses of MaltChainedException in org.maltparser.parser.guide.decision
 

Methods in org.maltparser.parser.guide.decision that throw MaltChainedException
 void OneDecisionModel.addInstance(GuideDecision decision)
           
 void DecisionModel.addInstance(GuideDecision decision)
           
 void BranchedDecisionModel.addInstance(GuideDecision decision)
           
 void SeqDecisionModel.addInstance(GuideDecision decision)
           
 FeatureVector OneDecisionModel.extract()
           
 FeatureVector DecisionModel.extract()
           
 FeatureVector BranchedDecisionModel.extract()
           
 FeatureVector SeqDecisionModel.extract()
           
 void OneDecisionModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 void BranchedDecisionModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 void SeqDecisionModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 void OneDecisionModel.noMoreInstances()
           
 void BranchedDecisionModel.noMoreInstances()
           
 void SeqDecisionModel.noMoreInstances()
           
 boolean OneDecisionModel.predict(GuideDecision decision)
           
 boolean DecisionModel.predict(GuideDecision decision)
           
 boolean BranchedDecisionModel.predict(GuideDecision decision)
           
 boolean SeqDecisionModel.predict(GuideDecision decision)
           
 FeatureVector OneDecisionModel.predictExtract(GuideDecision decision)
           
 FeatureVector DecisionModel.predictExtract(GuideDecision decision)
           
 FeatureVector BranchedDecisionModel.predictExtract(GuideDecision decision)
           
 FeatureVector SeqDecisionModel.predictExtract(GuideDecision decision)
           
 boolean OneDecisionModel.predictFromKBestList(GuideDecision decision)
           
 boolean DecisionModel.predictFromKBestList(GuideDecision decision)
           
 boolean BranchedDecisionModel.predictFromKBestList(GuideDecision decision)
           
 boolean SeqDecisionModel.predictFromKBestList(GuideDecision decision)
           
 void OneDecisionModel.terminate()
           
 void BranchedDecisionModel.terminate()
           
 void SeqDecisionModel.terminate()
           
 void OneDecisionModel.updateFeatureModel()
           
 void DecisionModel.updateFeatureModel()
           
 void BranchedDecisionModel.updateFeatureModel()
           
 void SeqDecisionModel.updateFeatureModel()
           
 

Constructors in org.maltparser.parser.guide.decision that throw MaltChainedException
BranchedDecisionModel(ClassifierGuide guide, DecisionModel parentDecisionModel, String branchedDecisionSymbol)
           
BranchedDecisionModel(ClassifierGuide guide, FeatureModel featureModel)
           
OneDecisionModel(ClassifierGuide guide, DecisionModel prevDecisionModel, String branchedDecisionSymbol)
           
OneDecisionModel(ClassifierGuide guide, FeatureModel featureModel)
           
SeqDecisionModel(ClassifierGuide guide, DecisionModel prevDecisionModel, String branchedDecisionSymbol)
           
SeqDecisionModel(ClassifierGuide guide, FeatureModel featureModel)
           
 

Uses of MaltChainedException in org.maltparser.parser.guide.instance
 

Methods in org.maltparser.parser.guide.instance that throw MaltChainedException
 void FeatureDivideModel.addInstance(SingleDecision decision)
           
 void InstanceModel.addInstance(SingleDecision decision)
           
 void AtomicModel.addInstance(SingleDecision decision)
           
 FeatureVector FeatureDivideModel.extract()
           
 FeatureVector InstanceModel.extract()
           
 FeatureVector AtomicModel.extract()
           
 void FeatureDivideModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 void AtomicModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 String FeatureDivideModel.getModelName()
           
 Model AtomicModel.getParent()
          Returns the parent guide model
 void AtomicModel.initMethod()
          Initialize the learning method according to the option --learner-method.
protected  void FeatureDivideModel.initSplitParam(FeatureVector featureVector)
          Initialize the feature split parameters and the split feature vector and master feature vector according to the behavior strategy.
protected  void FeatureDivideModel.load()
          Loads the feature divide model settings .fsm file.
 void AtomicModel.moveAllInstances(AtomicModel model, FeatureFunction divideFeature, ArrayList<Integer> divideFeatureIndexVector)
          Moves all instance from this atomic model into the destination atomic model and add the divide feature.
 void FeatureDivideModel.noMoreInstances()
           
 void AtomicModel.noMoreInstances()
           
 boolean FeatureDivideModel.predict(SingleDecision decision)
           
 boolean InstanceModel.predict(SingleDecision decision)
           
 boolean AtomicModel.predict(SingleDecision decision)
           
 FeatureVector FeatureDivideModel.predictExtract(SingleDecision decision)
           
 FeatureVector InstanceModel.predictExtract(SingleDecision decision)
           
 FeatureVector AtomicModel.predictExtract(SingleDecision decision)
           
protected  void FeatureDivideModel.save()
          Saves the feature divide model settings .fsm file.
protected  void FeatureDivideModel.setParent(Model parent)
          Sets the parent model
 void FeatureDivideModel.terminate()
           
 void AtomicModel.terminate()
           
 void FeatureDivideModel.train()
           
 void InstanceModel.train()
           
 void AtomicModel.train()
          Invokes the train() of the learning method
 

Constructors in org.maltparser.parser.guide.instance that throw MaltChainedException
AtomicModel(int index, FeatureVector features, Model parent)
          Constructs an atomic model.
FeatureDivideModel(FeatureVector features, Model parent)
          Constructs a feature divide model.
 

Uses of MaltChainedException in org.maltparser.parser.history
 

Subclasses of MaltChainedException in org.maltparser.parser.history
 class HistoryException
          HistoryException extends the MaltChainedException class and is thrown by classes within the history package.
 

Methods in org.maltparser.parser.history that throw MaltChainedException
 void GuideUserHistory.clear()
           
 void HistoryNode.clear()
           
abstract  void HistoryStructure.clear()
           
 void HistoryTree.clear()
           
 void HistoryList.clear()
           
 void HistoryTreeNode.clear()
           
 void HistoryListNode.clear()
           
 void History.clear()
           
abstract  void HistoryStructure.close()
           
 void HistoryTree.close()
           
 void HistoryList.close()
           
protected  ActionDecision History.getEmptyActionObject()
           
 GuideDecision GuideHistory.getEmptyGuideDecision()
           
 GuideDecision History.getEmptyGuideDecision()
           
 GuideUserAction GuideUserHistory.getEmptyGuideUserAction()
           
 GuideUserAction History.getEmptyGuideUserAction()
           
abstract  HistoryNode HistoryStructure.getNewHistoryNode(HistoryNode previousNode, GuideUserAction action)
           
 HistoryNode HistoryTree.getNewHistoryNode(HistoryNode previousNode, GuideUserAction action)
           
 HistoryNode HistoryList.getNewHistoryNode(HistoryNode previousNode, GuideUserAction action)
           
protected  void History.initDecisionSettings(String decisionSettings)
           
 void GuideHistory.setKBestListClass(Class<?> kBestListClass)
           
 void History.setKBestListClass(Class<?> kBestListClass)
           
 void GuideHistory.setSeparator(String separator)
           
 void History.setSeparator(String separator)
           
abstract  void HistoryStructure.toFile()
           
 void HistoryTree.toFile()
           
 void HistoryList.toFile()
           
 

Constructors in org.maltparser.parser.history that throw MaltChainedException
History(String decisionSettings, String separator, HashMap<String,TableHandler> tableHandlers)
           
HistoryList()
           
 

Uses of MaltChainedException in org.maltparser.parser.history.action
 

Methods in org.maltparser.parser.history.action that throw MaltChainedException
 void GuideUserAction.addAction(ActionContainer[] actionContainers)
           
 void ComplexDecisionAction.addAction(ActionContainer[] actionContainers)
           
 void GuideUserAction.addAction(ArrayList<ActionContainer> actionContainers)
           
 void ComplexDecisionAction.addAction(ArrayList<ActionContainer> actionContainers)
           
 void SimpleDecisionAction.addDecision(int code)
           
 void SingleDecision.addDecision(int code)
           
 void SimpleDecisionAction.addDecision(String symbol)
           
 void SingleDecision.addDecision(String symbol)
           
 boolean SimpleDecisionAction.continueWithNextDecision()
           
 boolean SingleDecision.continueWithNextDecision()
           
 void GuideUserAction.getAction(ActionContainer[] actionContainers)
           
 void ComplexDecisionAction.getAction(ActionContainer[] actionContainers)
           
 void GuideUserAction.getAction(ArrayList<ActionContainer> actionContainers)
           
 void ComplexDecisionAction.getAction(ArrayList<ActionContainer> actionContainers)
           
 int SimpleDecisionAction.getDecisionCode()
           
 int SingleDecision.getDecisionCode()
           
 int SimpleDecisionAction.getDecisionCode(String symbol)
           
 int SingleDecision.getDecisionCode(String symbol)
           
 String SimpleDecisionAction.getDecisionSymbol()
           
 String SingleDecision.getDecisionSymbol()
           
 KBestList SimpleDecisionAction.getKBestList()
           
 KBestList SingleDecision.getKBestList()
           
 void GuideUserAction.getKBestLists(ArrayList<ScoredKBestList> kbestListContainers)
           
 void ComplexDecisionAction.getKBestLists(ArrayList<ScoredKBestList> kbestListContainers)
           
 void GuideUserAction.getKBestLists(ScoredKBestList[] kbestListContainers)
           
 void ComplexDecisionAction.getKBestLists(ScoredKBestList[] kbestListContainers)
           
 SingleDecision MultipleDecision.getSingleDecision(int decisionIndex)
           
 SingleDecision ComplexDecisionAction.getSingleDecision(int decisionIndex)
           
 boolean SimpleDecisionAction.updateFromKBestList()
           
 boolean SingleDecision.updateFromKBestList()
           
 

Constructors in org.maltparser.parser.history.action that throw MaltChainedException
ComplexDecisionAction(GuideHistory history)
           
ComplexDecisionAction(History history)
           
SimpleDecisionAction(History history, TableContainer tableContainer)
           
 

Uses of MaltChainedException in org.maltparser.parser.history.container
 

Methods in org.maltparser.parser.history.container that throw MaltChainedException
 int CombinedTableContainer.addSymbol(String value)
           
 boolean TableContainer.containCode(int code)
           
 boolean CombinedTableContainer.containCode(int code)
           
 boolean TableContainer.containSymbol(String symbol)
           
 boolean CombinedTableContainer.containSymbol(String symbol)
           
 boolean TableContainer.continueWithNextDecision(int code)
           
 boolean DecisionPropertyTable.continueWithNextDecision(int code)
           
 boolean TableContainer.continueWithNextDecision(String symbol)
           
 boolean DecisionPropertyTable.continueWithNextDecision(String symbol)
           
 int TableContainer.getCode(String symbol)
           
 int CombinedTableContainer.getCode(String symbol)
           
 int CombinedTableContainer.getCombinedCode(ActionContainer[] codesToCombine, int start)
           
 int CombinedTableContainer.getCombinedCode(List<ActionContainer> codesToCombine)
           
 String TableContainer.getSymbol(int code)
           
 String CombinedTableContainer.getSymbol(int code)
           
 String CombinedTableContainer.getSymbolCodeToString(int code)
           
 int CombinedTableContainer.getSymbolStringToCode(String symbol)
           
 Table DecisionPropertyTable.getTableForNextDecision(int code)
           
 Table DecisionPropertyTable.getTableForNextDecision(String symbol)
           
protected  void CombinedTableContainer.initSymbolTable()
           
 String ActionContainer.setAction(int code)
           
 int ActionContainer.setAction(String symbol)
           
 void CombinedTableContainer.setActionContainer(ActionContainer[] actionContainers, int start, int decision)
           
 void CombinedTableContainer.setActionContainer(List<ActionContainer> actionContainers, int decision)
           
protected  void CombinedTableContainer.split()
           
 

Constructors in org.maltparser.parser.history.container that throw MaltChainedException
CombinedTableContainer(TableHandler tableHandler, String separator, List<TableContainer> containers, char decisionSeparator)
           
 

Uses of MaltChainedException in org.maltparser.parser.history.kbest
 

Methods in org.maltparser.parser.history.kbest that throw MaltChainedException
 void KBestList.add(int actionCode)
          Adds a candidate to the k-best list
 void ScoredKBestList.add(int actionCode, float score)
           
 void KBestList.add(String symbol)
          Adds a candidate to the k-best list
 void ScoredKBestList.add(String symbol, float score)
           
 void KBestList.addList(int[] predictionList)
           
 boolean KBestList.updateActionWithNextKBest()
          Updates the corresponding single decision with the next value in the k-best list.
 

Uses of MaltChainedException in org.maltparser.parser.transition
 

Methods in org.maltparser.parser.transition that throw MaltChainedException
 int TransitionTable.addSymbol(String symbol)
           
 Table TransitionTableHandler.addSymbolTable(String tableName)
           
 boolean TransitionTable.continueWithNextDecision(int code)
           
 boolean TransitionTable.continueWithNextDecision(String symbol)
           
 String TransitionTable.getSymbolCodeToString(int code)
           
 int TransitionTable.getSymbolStringToCode(String symbol)
           
 Table TransitionTableHandler.getSymbolTable(String tableName)
           
 Table TransitionTable.getTableForNextDecision(int code)
           
 Table TransitionTable.getTableForNextDecision(String symbol)
           
 

Uses of MaltChainedException in org.maltparser.transform.pseudo
 

Subclasses of MaltChainedException in org.maltparser.transform.pseudo
 class TransformationException
          TransformationException extends the MaltChainedException class and is thrown by classes within the transform package.
 

Methods in org.maltparser.transform.pseudo that throw MaltChainedException
 void PseudoProjectivity.deprojectivize(DependencyStructure pdg)
           
 void PseudoProjChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
           
 void PseudoProjectivity.initialize(String markingStrategyString, String coveredRoot, String liftingOrder, org.apache.log4j.Logger configLogger, DataFormatInstance dataFormatInstance)
           
 void PseudoProjectivity.mergeArclabels(DependencyStructure pdg)
           
 int PseudoProjChartItem.postprocess(int signal)
           
 int PseudoProjChartItem.preprocess(int signal)
           
 int PseudoProjChartItem.process(int signal)
           
 void PseudoProjectivity.projectivize(DependencyStructure pdg)
           
 void PseudoProjectivity.splitArclabels(DependencyStructure pdg)
           
 void PseudoProjChartItem.terminate()
           
 


MaltParser 1.6.1

Copyright 2007-2011 Johan Hall, Jens Nilsson and Joakim Nivre.