Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| MaltParser 1.5
PREV NEXT | FRAMES NO FRAMES

## 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)`
`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

Constructors in org.maltparser that throw MaltChainedException
`Engine()`
`MaltParserService()` Creates a MaltParserService with the option container 0
`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` | `ConfigDirChartItem.terminate()`
`void` | `ConfigurationDir.terminate()` Terminates the configuration directory
`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` | `MergeFeature.getCode(String symbol)`
`int` | `PrefixFeature.getCode(String symbol)`
`int` | `Merge3Feature.getCode(String symbol)`
`int` | `SuffixFeature.getCode(String symbol)`
`int` | `SplitFeature.getCode(String symbol)`
`String` | `MergeFeature.getSymbol(int code)`
`String` | `PrefixFeature.getSymbol(int code)`
`String` | `Merge3Feature.getSymbol(int code)`
`String` | `SuffixFeature.getSymbol(int code)`
`String` | `SplitFeature.getSymbol(int code)`
`void` | `MergeFeature.initialize(Object[] arguments)`
`void` | `PrefixFeature.initialize(Object[] arguments)`
`void` | `Merge3Feature.initialize(Object[] arguments)`
`void` | `SuffixFeature.initialize(Object[] arguments)`
`void` | `SplitFeature.initialize(Object[] arguments)`
`void` | `MergeFeature.update()`
`void` | `PrefixFeature.update()`
`void` | `Merge3Feature.update()`
`void` | `SuffixFeature.update()`
`void` | `SplitFeature.update()`
`void` | `MergeFeature.updateCardinality()`
`void` | `PrefixFeature.updateCardinality()`
`void` | `Merge3Feature.updateCardinality()`
`void` | `SuffixFeature.updateCardinality()`
`void` | `SplitFeature.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` | `FeatureSpecReader.load(URL specModelURL, SpecificationModels featureSpecModels)`
`void` | `ParReader.load(URL specModelURL, SpecificationModels featureSpecModels)`
`void` | `XmlReader.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)`
`static URL` | `Util.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
`static URL` | `Util.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 parentColumn)`
`ColumnDescription` | `DataFormatInstance.addInternalColumnDescription(String name, String category, String type, 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` | `ClassOption.addLegalValue(String value, String desc, String classname)` Adds a legal value that corresponds to a class
`void` | `StringEnumOption.addLegalValue(String value, String desc, String mapto)` Adds a legal value that corresponds to another string
`Object` | `StringOption.getDefaultValueObject()`
`Object` | `IntegerOption.getDefaultValueObject()`
`Object` | `BoolOption.getDefaultValueObject()`
`Object` | `UnaryOption.getDefaultValueObject()`
`abstract Object` | `Option.getDefaultValueObject()` Returns the object for the default value for option.
`Object` | `StringEnumOption.getDefaultValueObject()`
`Object` | `EnumOption.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)
`Object` | `ClassOption.getValueObject(String value)`
`Object` | `StringOption.getValueObject(String value)`
`Object` | `IntegerOption.getValueObject(String value)`
`Object` | `BoolOption.getValueObject(String value)`
`Object` | `UnaryOption.getValueObject(String value)`
`abstract Object` | `Option.getValueObject(String value)` Returns the corresponding object for the option value (specified as a string value).
`Object` | `StringEnumOption.getValueObject(String value)`
`Object` | `EnumOption.getValueObject(String value)`
`void` | `ClassOption.setDefaultValue(String defaultValue)`
`void` | `IntegerOption.setDefaultValue(String defaultValue)`
`void` | `BoolOption.setDefaultValue(String defaultValue)`
`void` | `UnaryOption.setDefaultValue(String defaultValue)`
`abstract void` | `Option.setDefaultValue(String defaultValue)` Sets the default value for the option.
`void` | `StringEnumOption.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
`void` | `ObjectPoolSet.checkIn(T t)`
`void` | `ObjectPoolList.checkIn(T o)`
`abstract void` | `ObjectPool.checkIn(T o)`
`void` | `ObjectPoolSet.checkInAll()`
`void` | `ObjectPoolList.checkInAll()`
`abstract void` | `ObjectPool.checkInAll()`
`T` | `ObjectPoolSet.checkOut()`
`T` | `ObjectPoolList.checkOut()`
`abstract T` | `ObjectPool.checkOut()`
`protected abstract T` | `ObjectPoolSet.create()`
`protected abstract T` | `ObjectPoolList.create()`
`protected abstract T` | `ObjectPool.create()`
`abstract void` | `ObjectPoolSet.resetObject(T o)`
`abstract void` | `ObjectPoolList.resetObject(T o)`
`abstract void` | `ObjectPool.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` | `PropagationManager.propagate(Edge e)`
`void` | `Propagations.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)`
`Table` | `TableHandler.addSymbolTable(String tableName)`
`SymbolTable` | `SymbolTableHandler.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)`
`Table` | `TableHandler.getSymbolTable(String tableName)`
`SymbolTable` | `SymbolTableHandler.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)`

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` | `MappablePhraseStructureGraph.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.
`DependencyNode` | `DependencyGraph.addDependencyNode()`
`DependencyNode` | `MappablePhraseStructureGraph.addDependencyNode()`
`DependencyNode` | `DependencyStructure.addDependencyNode()`
`DependencyNode` | `DependencyGraph.addDependencyNode(int index)`
`DependencyNode` | `MappablePhraseStructureGraph.addDependencyNode(int index)`
`DependencyNode` | `DependencyStructure.addDependencyNode(int index)`
`void` | `MappablePhraseStructureGraph.addLabel(Element element, String labelFunction, String label)`
`void` | `SyntaxGraph.addLabel(Element element, String labelFunction, String label)`
`void` | `LabeledStructure.addLabel(Element element, String tableName, String label)` Adds a label label to the graph element element
`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` | `MappablePhraseStructureGraph.addNonTerminalNode()`
`PhraseStructureNode` | `PhraseStructureGraph.addNonTerminalNode()`
`PhraseStructureNode` | `PhraseStructure.addNonTerminalNode(int index)`
`PhraseStructureNode` | `MappablePhraseStructureGraph.addNonTerminalNode(int index)`
`PhraseStructureNode` | `PhraseStructureGraph.addNonTerminalNode(int index)`
`Edge` | `PhraseStructure.addPhraseStructureEdge(PhraseStructureNode source, PhraseStructureNode target)`
`Edge` | `MappablePhraseStructureGraph.addPhraseStructureEdge(PhraseStructureNode parent, PhraseStructureNode child)`
`Edge` | `PhraseStructureGraph.addPhraseStructureEdge(PhraseStructureNode parent, PhraseStructureNode child)`
`Edge` | `DependencyGraph.addSecondaryEdge(ComparableNode source, ComparableNode target)`
`Edge` | `SecEdgeStructure.addSecondaryEdge(ComparableNode source, ComparableNode target)`
`Edge` | `MappablePhraseStructureGraph.addSecondaryEdge(ComparableNode source, ComparableNode target)`
`Edge` | `PhraseStructureGraph.addSecondaryEdge(ComparableNode source, ComparableNode target)`
`PhraseStructureNode` | `PhraseStructure.addTerminalNode()`
`PhraseStructureNode` | `MappablePhraseStructureGraph.addTerminalNode()`
`PhraseStructureNode` | `PhraseStructureGraph.addTerminalNode()`
`PhraseStructureNode` | `PhraseStructure.addTerminalNode(int index)`
`PhraseStructureNode` | `MappablePhraseStructureGraph.addTerminalNode(int index)`
`PhraseStructureNode` | `PhraseStructureGraph.addTerminalNode(int index)`
`TokenNode` | `Sentence.addTokenNode()`
`TokenNode` | `TokenStructure.addTokenNode()` Adds a token node with index n + 1, where n is the index of the last token node.
`TokenNode` | `Sentence.addTokenNode(int index)`
`TokenNode` | `TokenStructure.addTokenNode(int index)` Adds a token node with index index.
`void` | `SyntaxGraph.checkInLabelSet(LabelSet labelSet)`
`void` | `LabeledStructure.checkInLabelSet(LabelSet labelSet)` Checks in a label set.
`LabelSet` | `SyntaxGraph.checkOutNewLabelSet()`
`LabelSet` | `LabeledStructure.checkOutNewLabelSet()` Checks out a new label set from the structure.
`void` | `Structure.clear()` Resets the structure.
`void` | `DependencyGraph.clear()`
`void` | `Sentence.clear()`
`void` | `Element.clear()` Resets the graph element.
`void` | `GraphElement.clear()` Resets the graph element.
`void` | `MappablePhraseStructureGraph.clear()`
`void` | `SyntaxGraph.clear()`
`void` | `PhraseStructureGraph.clear()`
`void` | `CopyChartItem.copyPartialDependencyStructure(DependencyStructure sourceGraph, DependencyStructure targetGraph)`
`void` | `CopyChartItem.copyTerminalStructure(TokenStructure sourceGraph, TokenStructure targetGraph)`
`int` | `DependencyGraph.getDefaultRootEdgeLabelCode(SymbolTable table)`
`int` | `MappablePhraseStructureGraph.getDefaultRootEdgeLabelCode(SymbolTable table)`
`int` | `DependencyStructure.getDefaultRootEdgeLabelCode(SymbolTable table)` Returns the default edge label of the root as an integer value.
`LabelSet` | `DependencyGraph.getDefaultRootEdgeLabels()`
`LabelSet` | `MappablePhraseStructureGraph.getDefaultRootEdgeLabels()`
`LabelSet` | `DependencyStructure.getDefaultRootEdgeLabels()`
`String` | `DependencyGraph.getDefaultRootEdgeLabelSymbol(SymbolTable table)`
`String` | `MappablePhraseStructureGraph.getDefaultRootEdgeLabelSymbol(SymbolTable table)`
`String` | `DependencyStructure.getDefaultRootEdgeLabelSymbol(SymbolTable table)` Returns the default edge label of the root as a string value.
`Integer` | `RootLabels.getDefaultRootLabelCode(SymbolTable table)`
`LabelSet` | `RootLabels.getDefaultRootLabels()`
`String` | `RootLabels.getDefaultRootLabelSymbol(SymbolTable table)`
`DependencyNode` | `DependencyGraph.getDependencyNode(int index)`
`DependencyNode` | `MappablePhraseStructureGraph.getDependencyNode(int index)`
`DependencyNode` | `DependencyStructure.getDependencyNode(int index)` Returns the dependency node identified by index if it exists, otherwise null.
`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` | `MappablePhraseStructureGraph.getNonTerminalNode(int index)`
`PhraseStructureNode` | `PhraseStructureGraph.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` | `MappablePhraseStructureGraph.hasLabeledDependency(int index)`
`boolean` | `DependencyStructure.hasLabeledDependency(int index)` Returns true if the head edge of the dependency node with index is labeled, otherwise false.
`void` | `GraphAnalyzerChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)`
`void` | `CopyChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)`
`void` | `SyntaxGraphChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)`
`boolean` | `DependencyGraph.isProjective()`
`boolean` | `MappablePhraseStructureGraph.isProjective()`
`boolean` | `DependencyStructure.isProjective()` Returns true if all edges in the dependency structure are projective, otherwise false.
`void` | `MappablePhraseStructureGraph.linkAllTerminalsToRoot()`
`void` | `DependencyGraph.linkAllTreesToRoot()`
`void` | `MappablePhraseStructureGraph.linkAllTreesToRoot()`
`void` | `DependencyStructure.linkAllTreesToRoot()` Links all subtrees to the root of the dependency structure.
`protected Edge` | `DependencyGraph.moveDependencyEdge(DependencyNode newHead, DependencyNode dependent)`
`Edge` | `MappablePhraseStructureGraph.moveDependencyEdge(DependencyNode newHead, DependencyNode dependent)`
`Edge` | `DependencyGraph.moveDependencyEdge(int newHeadIndex, int dependentIndex)`
`Edge` | `MappablePhraseStructureGraph.moveDependencyEdge(int newHeadIndex, int dependentIndex)`
`Edge` | `DependencyStructure.moveDependencyEdge(int newHeadIndex, int dependentIndex)` Replace the head of the dependent with a new head.
`int` | `DependencyGraph.nNonProjectiveEdges()`
`int` | `MappablePhraseStructureGraph.nNonProjectiveEdges()`
`int` | `DependencyStructure.nNonProjectiveEdges()` Returns the number of non-projective edges in the dependency structure.
`int` | `GraphAnalyzerChartItem.postprocess(int signal)`
`int` | `CopyChartItem.postprocess(int signal)`
`int` | `SyntaxGraphChartItem.postprocess(int signal)`
`int` | `GraphAnalyzerChartItem.preprocess(int signal)`
`int` | `CopyChartItem.preprocess(int signal)`
`int` | `SyntaxGraphChartItem.preprocess(int signal)`
`int` | `GraphAnalyzerChartItem.process(int signal)`
`int` | `CopyChartItem.process(int signal)`
`int` | `SyntaxGraphChartItem.process(int signal)`
`void` | `DependencyGraph.removeDependencyEdge(int headIndex, int dependentIndex)`
`void` | `MappablePhraseStructureGraph.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.
`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` | `MappablePhraseStructureGraph.removePhraseStructureEdge(PhraseStructureNode parent, PhraseStructureNode child)`
`void` | `PhraseStructureGraph.removePhraseStructureEdge(PhraseStructureNode parent, PhraseStructureNode child)`
`void` | `DependencyGraph.removeSecondaryEdge(ComparableNode source, ComparableNode target)`
`void` | `SecEdgeStructure.removeSecondaryEdge(ComparableNode source, ComparableNode target)`
`void` | `MappablePhraseStructureGraph.removeSecondaryEdge(ComparableNode source, ComparableNode target)`
`void` | `PhraseStructureGraph.removeSecondaryEdge(ComparableNode source, ComparableNode target)`
`void` | `DependencyGraph.setDefaultRootEdgeLabel(SymbolTable table, String defaultRootSymbol)`
`void` | `MappablePhraseStructureGraph.setDefaultRootEdgeLabel(SymbolTable table, String defaultRootSymbol)`
`void` | `DependencyStructure.setDefaultRootEdgeLabel(SymbolTable table, String defaultRootSymbol)` Sets the default edge label of the root.
`void` | `DependencyGraph.setDefaultRootEdgeLabels(String rootLabelOption, SortedMap<String,SymbolTable> edgeSymbolTables)`
`void` | `MappablePhraseStructureGraph.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` | `RootLabels.setDefaultRootLabel(SymbolTable table, String defaultRootSymbol)`
`void` | `RootLabels.setRootLabels(String rootLabelOption, SortedMap<String,SymbolTable> edgeSymbolTables)`
`void` | `GraphAnalyzerChartItem.terminate()`
`void` | `CopyChartItem.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` | `OutputArcFeature.getCode(String symbol)`
`int` | `ExistsFeature.getCode(String symbol)` Returns the integer representation of the string `symbol` according to the exists feature function.
`int` | `ColumnFeature.getCode(String value)`
`int` | `DistanceFeature.getCode(String symbol)` Returns the integer representation of the string `symbol` according to the distance feature function.
`int` | `InputArcFeature.getCode(String symbol)`
`int` | `ArcDirFeature.getCode(String symbol)` Returns the integer representation of the string `symbol` according to the exists feature function.
`int` | `InputArcDirFeature.getCode(String symbol)`
`int` | `NumOfFeature.getCode(String symbol)` Returns the integer representation of the string `symbol` according to the numof feature function.
`String` | `OutputArcFeature.getSymbol(int code)`
`String` | `ExistsFeature.getSymbol(int code)` Returns the string representation of the integer `code` according to the exists feature function.
`String` | `ColumnFeature.getSymbol(int value)`
`String` | `DistanceFeature.getSymbol(int code)` Returns the string representation of the integer `code` according to the distance feature function.
`String` | `InputArcFeature.getSymbol(int code)`
`String` | `ArcDirFeature.getSymbol(int code)` Returns the string representation of the integer `code` according to the exists feature function.
`String` | `InputArcDirFeature.getSymbol(int code)`
`String` | `NumOfFeature.getSymbol(int code)` Returns the string representation of the integer `code` according to the numof feature function.
`void` | `OutputColumnFeature.initialize(Object[] arguments)`
`void` | `OutputArcFeature.initialize(Object[] arguments)`
`void` | `DGraphAddressFunction.initialize(Object[] arguments)`
`void` | `ExistsFeature.initialize(Object[] arguments)` Initialize the exists feature function
`abstract void` | `ColumnFeature.initialize(Object[] arguments)`
`void` | `InputColumnFeature.initialize(Object[] arguments)`
`void` | `DistanceFeature.initialize(Object[] arguments)` Initialize the distance feature function
`void` | `InputArcFeature.initialize(Object[] arguments)`
`void` | `ArcDirFeature.initialize(Object[] arguments)` Initialize the exists feature function
`void` | `InputArcDirFeature.initialize(Object[] arguments)`
`void` | `NumOfFeature.initialize(Object[] arguments)` Initialize the distance feature function
`void` | `OutputTableFeature.initialize(Object[] arguments)`
`void` | `InputTableFeature.initialize(Object[] arguments)`
`void` | `OutputArcFeature.setColumn(ColumnDescription column)`
`void` | `InputArcFeature.setColumn(ColumnDescription column)`
`void` | `InputArcDirFeature.setColumn(ColumnDescription column)`
`void` | `ColumnFeature.setFeatureValue(int indexCode)`
`void` | `ColumnFeature.setFeatureValue(String symbol)`
`void` | `OutputColumnFeature.update()`
`void` | `OutputArcFeature.update()`
`void` | `DGraphAddressFunction.update()`
`void` | `ExistsFeature.update()` Cause the feature function to update the feature value.
`abstract void` | `ColumnFeature.update()`
`void` | `InputColumnFeature.update()`
`void` | `DistanceFeature.update()` Cause the feature function to update the feature value.
`void` | `InputArcFeature.update()`
`void` | `ArcDirFeature.update()` Cause the feature function to update the feature value.
`void` | `InputArcDirFeature.update()`
`void` | `NumOfFeature.update()` Cause the feature function to update the feature value.
`void` | `OutputTableFeature.update()`
`void` | `InputTableFeature.update()`
`void` | `DGraphAddressFunction.update(Object[] arguments)`
`void` | `OutputArcFeature.updateCardinality()`
`void` | `InputArcFeature.updateCardinality()`
`void` | `InputArcDirFeature.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` | `Token.addHeadEdgeLabel(LabelSet labelSet)`
`void` | `DependencyNode.addHeadEdgeLabel(LabelSet labelSet)`
`void` | `Root.addHeadEdgeLabel(LabelSet labelSet)`
`void` | `Token.addHeadEdgeLabel(SymbolTable table, int code)`
`void` | `DependencyNode.addHeadEdgeLabel(SymbolTable table, int code)`
`void` | `Root.addHeadEdgeLabel(SymbolTable table, int code)`
`void` | `Token.addHeadEdgeLabel(SymbolTable table, String symbol)`
`void` | `DependencyNode.addHeadEdgeLabel(SymbolTable table, String symbol)`
`void` | `Root.addHeadEdgeLabel(SymbolTable table, String symbol)`
`void` | `NonTerminal.addIncomingEdge(Edge in)`
`void` | `GraphNode.addIncomingEdge(Edge in)`
`void` | `Token.addIncomingEdge(Edge in)`
`void` | `Node.addIncomingEdge(Edge in)`
`void` | `Root.addIncomingEdge(Edge in)`
`void` | `NonTerminal.addOutgoingEdge(Edge out)`
`void` | `GraphNode.addOutgoingEdge(Edge out)`
`void` | `Token.addOutgoingEdge(Edge out)`
`void` | `Node.addOutgoingEdge(Edge out)`
`void` | `Root.addOutgoingEdge(Edge out)`
`void` | `NonTerminal.clear()`
`void` | `GraphNode.clear()`
`void` | `Token.clear()`
`void` | `Root.clear()`
`DependencyNode` | `Token.getAncestor()`
`DependencyNode` | `DependencyNode.getAncestor()`
`DependencyNode` | `Root.getAncestor()`
`int` | `Token.getDependencyNodeDepth()`
`int` | `DependencyNode.getDependencyNodeDepth()` Returns the depth of the node.
`int` | `Root.getDependencyNodeDepth()`
`DependencyNode` | `Token.getHead()`
`DependencyNode` | `DependencyNode.getHead()` Returns the head dependency node if it exists, otherwise null.
`DependencyNode` | `Root.getHead()`
`PhraseStructureNode` | `NonTerminalNode.getHeadChild()`
`PhraseStructureNode` | `NonTerminal.getHeadChild()`
`PhraseStructureNode` | `Root.getHeadChild()`
`PhraseStructureNode` | `NonTerminalNode.getHeadChild(HeadRules headRules)`
`PhraseStructureNode` | `NonTerminal.getHeadChild(HeadRules headRules)`
`PhraseStructureNode` | `Root.getHeadChild(HeadRules headRules)`
`Edge` | `Token.getHeadEdge()`
`Edge` | `DependencyNode.getHeadEdge()` Returns the edge between the head and the node if it exists, otherwise null.
`Edge` | `Root.getHeadEdge()`
`int` | `Token.getHeadEdgeLabelCode(SymbolTable table)`
`int` | `DependencyNode.getHeadEdgeLabelCode(SymbolTable table)`
`int` | `Root.getHeadEdgeLabelCode(SymbolTable table)`
`LabelSet` | `Token.getHeadEdgeLabelSet()`
`LabelSet` | `DependencyNode.getHeadEdgeLabelSet()`
`LabelSet` | `Root.getHeadEdgeLabelSet()`
`String` | `Token.getHeadEdgeLabelSymbol(SymbolTable table)`
`String` | `DependencyNode.getHeadEdgeLabelSymbol(SymbolTable table)`
`String` | `Root.getHeadEdgeLabelSymbol(SymbolTable table)`
`Set<SymbolTable>` | `Token.getHeadEdgeLabelTypes()`
`Set<SymbolTable>` | `DependencyNode.getHeadEdgeLabelTypes()`
`Set<SymbolTable>` | `Root.getHeadEdgeLabelTypes()`
`Set<Edge>` | `Token.getHeadEdges()`
`Set<Edge>` | `DependencyNode.getHeadEdges()`
`Set<Edge>` | `Root.getHeadEdges()`
`Set<DependencyNode>` | `Token.getHeads()`
`Set<DependencyNode>` | `DependencyNode.getHeads()`
`Set<DependencyNode>` | `Root.getHeads()`
`ComparableNode` | `NonTerminal.getLeftmostDescendant()`
`ComparableNode` | `Token.getLeftmostDescendant()`
`ComparableNode` | `ComparableNode.getLeftmostDescendant()` Returns the left-most terminal descendant node.
`ComparableNode` | `Root.getLeftmostDescendant()`
`int` | `GraphNode.getLeftmostDescendantIndex()`
`int` | `ComparableNode.getLeftmostDescendantIndex()` Returns the index of the left-most terminal descendant node.
`ComparableNode` | `Token.getLeftmostProperDescendant()`
`ComparableNode` | `ComparableNode.getLeftmostProperDescendant()` Returns the left-most proper terminal descendant node (excluding itself).
`ComparableNode` | `Root.getLeftmostProperDescendant()`
`int` | `GraphNode.getLeftmostProperDescendantIndex()`
`int` | `ComparableNode.getLeftmostProperDescendantIndex()` Returns the index of the left-most proper terminal descendant node (excluding itself).
`DependencyNode` | `Token.getLeftSibling()` Returns the left sibling if it exists, otherwise `null`
`DependencyNode` | `DependencyNode.getLeftSibling()` Returns the left sibling if it exists, otherwise `null`
`DependencyNode` | `Root.getLeftSibling()` Returns the left sibling if it exists, otherwise `null`
`TokenNode` | `NonTerminalNode.getLexicalHead()`
`TokenNode` | `NonTerminal.getLexicalHead()`
`TokenNode` | `Root.getLexicalHead()`
`TokenNode` | `NonTerminalNode.getLexicalHead(HeadRules headRules)`
`TokenNode` | `NonTerminal.getLexicalHead(HeadRules headRules)`
`TokenNode` | `Root.getLexicalHead(HeadRules headRules)`
`Edge` | `NonTerminal.getParentEdge()`
`Edge` | `Token.getParentEdge()`
`Edge` | `PhraseStructureNode.getParentEdge()`
`Edge` | `Root.getParentEdge()`
`int` | `NonTerminal.getParentEdgeLabelCode(SymbolTable table)`
`int` | `Token.getParentEdgeLabelCode(SymbolTable table)`
`int` | `PhraseStructureNode.getParentEdgeLabelCode(SymbolTable table)`
`int` | `Root.getParentEdgeLabelCode(SymbolTable table)`
`String` | `NonTerminal.getParentEdgeLabelSymbol(SymbolTable table)`
`String` | `Token.getParentEdgeLabelSymbol(SymbolTable table)`
`String` | `PhraseStructureNode.getParentEdgeLabelSymbol(SymbolTable table)`
`String` | `Root.getParentEdgeLabelSymbol(SymbolTable table)`
`DependencyNode` | `Token.getProperAncestor()`
`DependencyNode` | `DependencyNode.getProperAncestor()`
`DependencyNode` | `Root.getProperAncestor()`
`ComparableNode` | `NonTerminal.getRightmostDescendant()`
`ComparableNode` | `Token.getRightmostDescendant()`
`ComparableNode` | `ComparableNode.getRightmostDescendant()` Returns the right-most terminal descendant node.
`ComparableNode` | `Root.getRightmostDescendant()`
`int` | `GraphNode.getRightmostDescendantIndex()`
`int` | `ComparableNode.getRightmostDescendantIndex()` Returns the index of the right-most terminal descendant node.
`ComparableNode` | `Token.getRightmostProperDescendant()`
`ComparableNode` | `ComparableNode.getRightmostProperDescendant()` Returns the right-most proper terminal descendant node (excluding itself).
`ComparableNode` | `Root.getRightmostProperDescendant()`
`int` | `GraphNode.getRightmostProperDescendantIndex()`
`int` | `ComparableNode.getRightmostProperDescendantIndex()` Returns the index of the right-most proper terminal descendant node (excluding itself).
`DependencyNode` | `Token.getRightSibling()` Returns the right sibling if it exists, otherwise `null`
`DependencyNode` | `DependencyNode.getRightSibling()` Returns the right sibling if it exists, otherwise `null`
`DependencyNode` | `Root.getRightSibling()` Returns the right sibling if it exists, otherwise `null`
`DependencyNode` | `Token.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` | `Root.getSameSideLeftSibling()` Returns the left 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.
`DependencyNode` | `DependencyNode.getSameSideRightSibling()` Returns the right 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.
`boolean` | `Token.hasAncestorInside(int left, int right)`
`boolean` | `DependencyNode.hasAncestorInside(int left, int right)`
`boolean` | `Root.hasAncestorInside(int left, int right)`
`boolean` | `Token.hasHeadEdgeLabel(SymbolTable table)`
`boolean` | `DependencyNode.hasHeadEdgeLabel(SymbolTable table)`
`boolean` | `Root.hasHeadEdgeLabel(SymbolTable table)`
`boolean` | `NonTerminal.hasParentEdgeLabel(SymbolTable table)`
`boolean` | `Token.hasParentEdgeLabel(SymbolTable table)`
`boolean` | `PhraseStructureNode.hasParentEdgeLabel(SymbolTable table)`
`boolean` | `Root.hasParentEdgeLabel(SymbolTable table)`
`TokenNode` | `NonTerminalNode.identifyHead(HeadRules headRules)`
`TokenNode` | `NonTerminal.identifyHead(HeadRules headRules)`
`TokenNode` | `Root.identifyHead(HeadRules headRules)`
`boolean` | `Token.isHeadEdgeLabeled()`
`boolean` | `DependencyNode.isHeadEdgeLabeled()`
`boolean` | `Root.isHeadEdgeLabeled()`
`boolean` | `Token.isProjective()`
`boolean` | `DependencyNode.isProjective()` Returns true if the head edge is projective, otherwise false.
`boolean` | `Root.isProjective()`
`int` | `Token.nHeadEdgeLabels()`
`int` | `DependencyNode.nHeadEdgeLabels()`
`int` | `Root.nHeadEdgeLabels()`
`void` | `NonTerminal.removeIncomingEdge(Edge in)`
`void` | `GraphNode.removeIncomingEdge(Edge in)`
`void` | `Token.removeIncomingEdge(Edge in)`
`void` | `Node.removeIncomingEdge(Edge in)`
`void` | `NonTerminal.removeOutgoingEdge(Edge out)`
`void` | `GraphNode.removeOutgoingEdge(Edge out)`
`void` | `Token.removeOutgoingEdge(Edge out)`
`void` | `Node.removeOutgoingEdge(Edge out)`
`void` | `Root.removeOutgoingEdge(Edge out)`
`void` | `NonTerminal.setIndex(int index)`
`abstract void` | `GraphNode.setIndex(int index)`
`void` | `Token.setIndex(int index)`
`void` | `Node.setIndex(int index)`
`void` | `Root.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` | `NegraReader.close()`
`void` | `BracketReader.close()`
`void` | `SyntaxGraphReader.close()` Closes the file or the input stream.
`void` | `TabReader.close()`
`int` | `BracketReader.getSentenceCount()`
`int` | `SyntaxGraphReader.getSentenceCount()` Returns the current number of the sentence.
`int` | `TabReader.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` | `NegraReader.open(InputStream is, String charsetName)`
`void` | `BracketReader.open(InputStream is, String charsetName)`
`void` | `SyntaxGraphReader.open(InputStream is, String charsetName)` Opens an input stream
`void` | `TabReader.open(InputStream is, String charsetName)`
`void` | `TigerXMLReader.open(String fileName, String charsetName)`
`void` | `NegraReader.open(String fileName, String charsetName)`
`void` | `BracketReader.open(String fileName, String charsetName)`
`void` | `SyntaxGraphReader.open(String fileName, String charsetName)` Opens a file for read only
`void` | `TabReader.open(String fileName, String charsetName)`
`void` | `TigerXMLReader.open(URL url, String charsetName)`
`void` | `NegraReader.open(URL url, String charsetName)`
`void` | `BracketReader.open(URL url, String charsetName)`
`void` | `SyntaxGraphReader.open(URL url, String charsetName)` Opens an URL for read only
`void` | `TabReader.open(URL url, String charsetName)`
`int` | `ReadChartItem.postprocess(int signal)`
`int` | `ReadChartItem.preprocess(int signal)`
`int` | `ReadChartItem.process(int signal)`
`void` | `TigerXMLReader.readEpilog()`
`void` | `NegraReader.readEpilog()`
`void` | `BracketReader.readEpilog()`
`void` | `SyntaxGraphReader.readEpilog()` Reads the end of the file, after all sentences have been processed,
`void` | `TabReader.readEpilog()`
`void` | `TigerXMLReader.readProlog()`
`void` | `NegraReader.readProlog()`
`void` | `BracketReader.readProlog()`
`void` | `SyntaxGraphReader.readProlog()` Cause the syntax graph reader to read the beginning of the file (such as header information)
`void` | `TabReader.readProlog()`
`boolean` | `TigerXMLReader.readSentence(TokenStructure syntaxGraph)`
`boolean` | `NegraReader.readSentence(TokenStructure syntaxGraph)`
`boolean` | `BracketReader.readSentence(TokenStructure syntaxGraph)`
`boolean` | `SyntaxGraphReader.readSentence(TokenStructure syntaxGraph)` Reads a sentence (token structure, dependency structure or/and phrase structure)
`boolean` | `TabReader.readSentence(TokenStructure syntaxGraph)`
`void` | `TigerXMLReader.setOptions(String optionString)`
`void` | `NegraReader.setOptions(String optionString)`
`void` | `BracketReader.setOptions(String optionString)`
`void` | `SyntaxGraphReader.setOptions(String optionString)` Sets the reader specific options.
`void` | `TabReader.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` | `NegraWriter.close()`
`void` | `SyntaxGraphWriter.close()` Closes the file or the output stream.
`void` | `TigerXMLWriter.close()`
`void` | `TabWriter.close()`
`void` | `BracketWriter.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` | `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(OutputStream os, String charsetName)`
`void` | `BracketWriter.open(OutputStream os, 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)`
`void` | `TabWriter.open(String fileName, String charsetName)`
`void` | `BracketWriter.open(String fileName, String charsetName)`
`int` | `WriteChartItem.postprocess(int signal)`
`int` | `WriteChartItem.preprocess(int signal)`
`int` | `WriteChartItem.process(int signal)`
`void` | `NegraWriter.setOptions(String optionString)`
`void` | `SyntaxGraphWriter.setOptions(String optionString)` Sets the writer specific options.
`void` | `TigerXMLWriter.setOptions(String optionString)`
`void` | `TabWriter.setOptions(String optionString)`
`void` | `BracketWriter.setOptions(String optionString)`
`void` | `WriteChartItem.setSyntaxGraphWriterClass(Class<?> graphWriterClass)`
`void` | `TabWriter.setWriter(BufferedWriter writer)`
`void` | `BracketWriter.setWriter(BufferedWriter writer)`
`void` | `WriteChartItem.terminate()`
`void` | `NegraWriter.writeEpilog()`
`void` | `SyntaxGraphWriter.writeEpilog()` Writes the end of the file
`void` | `TigerXMLWriter.writeEpilog()`
`void` | `TabWriter.writeEpilog()`
`void` | `BracketWriter.writeEpilog()`
`void` | `TigerXMLWriter.writeNonTerminal(NonTerminalNode nt, String id)`
`void` | `TigerXMLWriter.writeNonTerminals(PhraseStructure phraseStructure)`
`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.writeProlog()`
`void` | `BracketWriter.writeProlog()`
`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)`
`void` | `TabWriter.writeSentence(TokenStructure syntaxGraph)`
`void` | `BracketWriter.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` | `LibLinear.terminate()`
`void` | `Lib.terminate()`
`void` | `Lib.train(FeatureVector featureVector)`
`protected void` | `LibSvm.trainExternal(FeatureVector featureVector)`
`protected void` | `LibLinear.trainExternal(FeatureVector featureVector)`
`protected abstract void` | `Lib.trainExternal(FeatureVector featureVector)`
`protected void` | `LibSvm.trainInternal(FeatureVector featureVector)`
`protected void` | `LibLinear.trainInternal(FeatureVector featureVector)`
`protected abstract void` | `Lib.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()`
`void` | `ParserState.clear()`
`abstract void` | `ParserConfiguration.clear()` Clears the parser configuration
`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)`
`boolean` | `ParserState.isTerminalState()`
`abstract boolean` | `ParserConfiguration.isTerminalState()` Returns true if the parser configuration is in a terminal state, otherwise false.
`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` | `DependencyParserConfig.oracleParse(DependencyStructure goldGraph, DependencyStructure oracleGraph)`
`void` | `SingleMalt.oracleParse(DependencyStructure goldGraph, DependencyStructure oracleGraph)`
`void` | `DependencyParserConfig.parse(DependencyStructure graph)`
`DependencyStructure` | `DeterministicParser.parse(DependencyStructure parseDependencyGraph)`
`void` | `SingleMalt.parse(DependencyStructure graph)`
`abstract DependencyStructure` | `Parser.parse(DependencyStructure parseDependencyGraph)` Parses the empty dependency graph
`abstract DependencyStructure` | `Trainer.parse(DependencyStructure goldDependencyGraph, DependencyStructure parseDependencyGraph)` Trains a parser using the gold-standard dependency graph and returns a parsed dependency graph
`DependencyStructure` | `BatchTrainer.parse(DependencyStructure goldDependencyGraph, DependencyStructure parseDependencyGraph)`
`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` | `SingleMaltChartItem.terminate()`
`abstract void` | `Algorithm.terminate()`
`void` | `DeterministicParser.terminate()`
`void` | `BatchTrainer.terminate()`
`void` | `SingleMalt.terminate(Object[] arguments)`
`abstract void` | `Trainer.train()`
`void` | `SingleMalt.train()`
`void` | `BatchTrainer.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` | `CovingtonProjFactory.makeOracleGuide(GuideUserHistory history)`
`OracleGuide` | `CovingtonNonProjFactory.makeOracleGuide(GuideUserHistory history)`
`ParserConfiguration` | `CovingtonFactory.makeParserConfiguration()`
`TransitionSystem` | `CovingtonProjFactory.makeTransitionSystem()`
`TransitionSystem` | `CovingtonNonProjFactory.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` | `ArcEager.addAvailableTransitionToTable(TransitionTable ttable)`
`protected void` | `ArcStandard.addAvailableTransitionToTable(TransitionTable ttable)`
`void` | `ArcEager.apply(GuideUserAction currentAction, ParserConfiguration config)`
`void` | `ArcStandard.apply(GuideUserAction currentAction, ParserConfiguration config)`
`void` | `NivreConfig.clear()`
`GuideUserAction` | `ArcEager.defaultAction(GuideUserHistory history, ParserConfiguration configuration)`
`GuideUserAction` | `ArcStandard.defaultAction(GuideUserHistory history, ParserConfiguration configuration)`
`void` | `ArcStandardOracle.finalizeSentence(DependencyStructure dependencyGraph)`
`void` | `ArcEagerOracle.finalizeSentence(DependencyStructure dependencyGraph)`
`GuideUserAction` | `ArcEager.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)`
`GuideUserAction` | `ArcStandard.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` | `ArcEager.initWithDefaultTransitions(GuideUserHistory history)`
`protected void` | `ArcStandard.initWithDefaultTransitions(GuideUserHistory history)`
`Function` | `NivreFactory.makeFunction(String subFunctionName)`
`OracleGuide` | `NivreArcStandardFactory.makeOracleGuide(GuideUserHistory history)`
`OracleGuide` | `NivreArcEagerFactory.makeOracleGuide(GuideUserHistory history)`
`ParserConfiguration` | `NivreFactory.makeParserConfiguration()`
`TransitionSystem` | `NivreArcStandardFactory.makeTransitionSystem()`
`TransitionSystem` | `NivreArcEagerFactory.makeTransitionSystem()`
`boolean` | `ArcEager.permissible(GuideUserAction currentAction, ParserConfiguration config)`
`boolean` | `ArcStandard.permissible(GuideUserAction currentAction, ParserConfiguration config)`
`GuideUserAction` | `ArcStandardOracle.predict(DependencyStructure gold, ParserConfiguration config)`
`GuideUserAction` | `ArcEagerOracle.predict(DependencyStructure gold, ParserConfiguration config)`
`void` | `NivreConfig.setDependencyGraph(DependencyStructure source)`
`protected void` | `NivreConfig.setRootHandling(String rh)`
`void` | `ArcStandardOracle.terminate()`
`void` | `ArcEagerOracle.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` | `ProjectiveOracle.finalizeSentence(DependencyStructure dependencyGraph)`
`void` | `SwapEagerOracle.finalizeSentence(DependencyStructure dependencyGraph)`
`void` | `SwapLazyOracle.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` | `StackSwapEagerFactory.makeOracleGuide(GuideUserHistory history)`
`OracleGuide` | `StackProjFactory.makeOracleGuide(GuideUserHistory history)`
`ParserConfiguration` | `StackFactory.makeParserConfiguration()`
`TransitionSystem` | `StackSwapLazyFactory.makeTransitionSystem()`
`TransitionSystem` | `StackSwapEagerFactory.makeTransitionSystem()`
`TransitionSystem` | `StackProjFactory.makeTransitionSystem()`
`boolean` | `Projective.permissible(GuideUserAction currentAction, ParserConfiguration configuration)`
`boolean` | `NonProjective.permissible(GuideUserAction currentAction, ParserConfiguration configuration)`
`GuideUserAction` | `ProjectiveOracle.predict(DependencyStructure gold, ParserConfiguration configuration)`
`GuideUserAction` | `SwapEagerOracle.predict(DependencyStructure gold, ParserConfiguration configuration)`
`GuideUserAction` | `SwapLazyOracle.predict(DependencyStructure gold, ParserConfiguration configuration)`
`void` | `StackConfig.setDependencyGraph(DependencyStructure source)`
`void` | `ProjectiveOracle.terminate()`
`void` | `SwapEagerOracle.terminate()`
`void` | `SwapLazyOracle.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` | `BranchedDecisionModel.addInstance(GuideDecision decision)`
`void` | `SeqDecisionModel.addInstance(GuideDecision decision)`
`void` | `DecisionModel.addInstance(GuideDecision decision)`
`FeatureVector` | `OneDecisionModel.extract()`
`FeatureVector` | `BranchedDecisionModel.extract()`
`FeatureVector` | `SeqDecisionModel.extract()`
`FeatureVector` | `DecisionModel.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` | `BranchedDecisionModel.predict(GuideDecision decision)`
`boolean` | `SeqDecisionModel.predict(GuideDecision decision)`
`boolean` | `DecisionModel.predict(GuideDecision decision)`
`FeatureVector` | `OneDecisionModel.predictExtract(GuideDecision decision)`
`FeatureVector` | `BranchedDecisionModel.predictExtract(GuideDecision decision)`
`FeatureVector` | `SeqDecisionModel.predictExtract(GuideDecision decision)`
`FeatureVector` | `DecisionModel.predictExtract(GuideDecision decision)`
`boolean` | `OneDecisionModel.predictFromKBestList(GuideDecision decision)`
`boolean` | `BranchedDecisionModel.predictFromKBestList(GuideDecision decision)`
`boolean` | `SeqDecisionModel.predictFromKBestList(GuideDecision decision)`
`boolean` | `DecisionModel.predictFromKBestList(GuideDecision decision)`
`void` | `OneDecisionModel.terminate()`
`void` | `BranchedDecisionModel.terminate()`
`void` | `SeqDecisionModel.terminate()`
`void` | `OneDecisionModel.updateFeatureModel()`
`void` | `BranchedDecisionModel.updateFeatureModel()`
`void` | `SeqDecisionModel.updateFeatureModel()`
`void` | `DecisionModel.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` | `AtomicModel.addInstance(SingleDecision decision)`
`void` | `FeatureDivideModel.addInstance(SingleDecision decision)`
`void` | `InstanceModel.addInstance(SingleDecision decision)`
`FeatureVector` | `AtomicModel.extract()`
`FeatureVector` | `FeatureDivideModel.extract()`
`FeatureVector` | `InstanceModel.extract()`
`void` | `AtomicModel.finalizeSentence(DependencyStructure dependencyGraph)`
`void` | `FeatureDivideModel.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` | `AtomicModel.noMoreInstances()`
`void` | `FeatureDivideModel.noMoreInstances()`
`boolean` | `AtomicModel.predict(SingleDecision decision)`
`boolean` | `FeatureDivideModel.predict(SingleDecision decision)`
`boolean` | `InstanceModel.predict(SingleDecision decision)`
`FeatureVector` | `AtomicModel.predictExtract(SingleDecision decision)`
`FeatureVector` | `FeatureDivideModel.predictExtract(SingleDecision decision)`
`FeatureVector` | `InstanceModel.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` | `AtomicModel.terminate()`
`void` | `FeatureDivideModel.terminate()`
`void` | `AtomicModel.train()` Invokes the train() of the learning method
`void` | `FeatureDivideModel.train()`
`void` | `InstanceModel.train()`

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` | `HistoryList.clear()`
`void` | `HistoryListNode.clear()`
`void` | `History.clear()`
`void` | `GuideUserHistory.clear()`
`abstract void` | `HistoryStructure.clear()`
`void` | `HistoryTreeNode.clear()`
`void` | `HistoryTree.clear()`
`void` | `HistoryNode.clear()`
`void` | `HistoryList.close()`
`abstract void` | `HistoryStructure.close()`
`void` | `HistoryTree.close()`
`protected ActionDecision` | `History.getEmptyActionObject()`
`GuideDecision` | `GuideHistory.getEmptyGuideDecision()`
`GuideDecision` | `History.getEmptyGuideDecision()`
`GuideUserAction` | `History.getEmptyGuideUserAction()`
`GuideUserAction` | `GuideUserHistory.getEmptyGuideUserAction()`
`HistoryNode` | `HistoryList.getNewHistoryNode(HistoryNode previousNode, GuideUserAction action)`
`abstract HistoryNode` | `HistoryStructure.getNewHistoryNode(HistoryNode previousNode, GuideUserAction action)`
`HistoryNode` | `HistoryTree.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)`
`void` | `HistoryList.toFile()`
`abstract void` | `HistoryStructure.toFile()`
`void` | `HistoryTree.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` | `ComplexDecisionAction.addAction(ActionContainer[] actionContainers)`
`void` | `GuideUserAction.addAction(ActionContainer[] actionContainers)`
`void` | `ComplexDecisionAction.addAction(ArrayList<ActionContainer> actionContainers)`
`void` | `GuideUserAction.addAction(ArrayList<ActionContainer> actionContainers)`
`void` | `SingleDecision.addDecision(int code)`
`void` | `SimpleDecisionAction.addDecision(int code)`
`void` | `SingleDecision.addDecision(String symbol)`
`void` | `SimpleDecisionAction.addDecision(String symbol)`
`boolean` | `SingleDecision.continueWithNextDecision()`
`boolean` | `SimpleDecisionAction.continueWithNextDecision()`
`void` | `ComplexDecisionAction.getAction(ActionContainer[] actionContainers)`
`void` | `GuideUserAction.getAction(ActionContainer[] actionContainers)`
`void` | `ComplexDecisionAction.getAction(ArrayList<ActionContainer> actionContainers)`
`void` | `GuideUserAction.getAction(ArrayList<ActionContainer> actionContainers)`
`int` | `SingleDecision.getDecisionCode()`
`int` | `SimpleDecisionAction.getDecisionCode()`
`int` | `SingleDecision.getDecisionCode(String symbol)`
`int` | `SimpleDecisionAction.getDecisionCode(String symbol)`
`String` | `SingleDecision.getDecisionSymbol()`
`String` | `SimpleDecisionAction.getDecisionSymbol()`
`KBestList` | `SingleDecision.getKBestList()`
`KBestList` | `SimpleDecisionAction.getKBestList()`
`void` | `ComplexDecisionAction.getKBestLists(ArrayList<ScoredKBestList> kbestListContainers)`
`void` | `GuideUserAction.getKBestLists(ArrayList<ScoredKBestList> kbestListContainers)`
`void` | `ComplexDecisionAction.getKBestLists(ScoredKBestList[] kbestListContainers)`
`void` | `GuideUserAction.getKBestLists(ScoredKBestList[] kbestListContainers)`
`SingleDecision` | `ComplexDecisionAction.getSingleDecision(int decisionIndex)`
`SingleDecision` | `MultipleDecision.getSingleDecision(int decisionIndex)`
`protected void` | `ComplexDecisionAction.initDecisions()`
`boolean` | `SingleDecision.updateFromKBestList()`
`boolean` | `SimpleDecisionAction.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()`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| MaltParser 1.5
PREV NEXT | FRAMES NO FRAMES

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