MaltParser 1.3

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.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.liblinear Contains classes that interacts with the Liblinear learner. 
org.maltparser.ml.libsvm Contains classes that interacts with the LIBSVM learner. 
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.stack Implements the Stack parsing algorithms. 
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.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 Engine.process(int optionContainerIndex)
           
 void Engine.terminate(int optionContainerIndex)
           
 

Constructors in org.maltparser that throw MaltChainedException
Engine()
           
 

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.copyToConfig(File source)
          Copies a file into the configuration directory.
 void ConfigurationDir.copyToConfig(String fileUrl)
          Copies a file into the configuration directory.
 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
 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
 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
 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
protected  void ConfigurationDir.initCreatedByMaltParserVersionFromInfoFile()
           
 void ConfigDirChartItem.initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification)
           
protected  void ConfigurationDir.initNameNTypeFromInfoFile(URL url)
           
 void ConfigurationDir.initWorkingDirectory()
          Initialize the working directory
 void ConfigurationDir.initWorkingDirectory(String pathPrefixString)
          Initialize the working directory according to the path.
 int ConfigDirChartItem.postprocess(int signal)
           
 int ConfigDirChartItem.preprocess(int signal)
           
 int ConfigDirChartItem.process(int signal)
           
 void ConfigurationDir.terminate()
          Terminates the configuration directory
 void ConfigDirChartItem.terminate()
           
 void ConfigurationDir.unpackConfigFile()
          Unpacks the malt configuration file (.mco).
protected  void ConfigurationDir.unpackConfigFile(JarInputStream jis)
           
 

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, boolean malt04, String markingStrategy, String coveredRoot)
           
 void FeatureModelManager.loadParSpecification(URL specModelURL, boolean malt04, String markingStrategy, String coveredRoot)
           
 void FeatureModelManager.loadSpecification(String specModelFileName)
           
 void FeatureModelManager.loadSpecification(URL specModelURL)
           
 Function AbstractFeatureFactory.makeFunction(String subFunctionName)
           
 void FeatureVector.update()
          Updates all feature value in the feature vector according to the current state.
 void FeatureModel.update()
           
 void FeatureModel.update(Object[] arguments)
           
 void FeatureVector.updateCardinality()
          Updates the cardinality (number of distinct values) of a feature value associated with the feature function
 void FeatureModel.updateCardinality()
           
 

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)
           
 void FeatureFunction.updateCardinality()
          Cause the feature function to update the cardinality of the feature value.
 

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

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

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

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 SpecificationModels.add(String specModelName, String featureSpec)
           
 void SpecificationModel.add(String subModelName, String featureSpec)
           
 void SpecificationModels.add(String specModelName, String subModelName, String featureSpec)
           
 SpecificationModel SpecificationModels.getSpecificationModel(String specModelURL, int specModelUrlIndex)
           
 void SpecificationModels.load(String specModelFileName)
           
 void SpecificationModels.load(URL specModelURL)
           
 void SpecificationModels.loadParReader(String specModelFileName, boolean malt04, String markingStrategy, String coveredRoot)
           
 void SpecificationModels.loadParReader(URL specModelURL, boolean malt04, String markingStrategy, String coveredRoot)
           
 

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

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

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

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

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

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

Uses of MaltChainedException in org.maltparser.core.flow
 

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

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

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

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

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

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

Methods in org.maltparser.core.flow.spec that throw MaltChainedException
 void ChartSpecification.read(Element chartElem, FlowChartManager flowCharts)
           
 void ChartItemSpecification.read(Element chartItemSpec, 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 ChartElement.read(Element chartElem, FlowChartSystem flowChartSystem)
           
 void ChartAttribute.read(Element attrElem, FlowChartSystem flowChartSystem)
           
 

Uses of MaltChainedException in org.maltparser.core.helper
 

Methods in org.maltparser.core.helper that throw MaltChainedException
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 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, String rootLabels, 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
 DataFormatInstance DataFormatSpecification.createDataFormatInstance(SymbolTableHandler symbolTables, String nullValueStrategy, String rootLabel)
           
 DataFormatSpecification DataFormatManager.loadDataFormat(String dataFormatName)
           
 void DataFormatSpecification.parseDataFormatXMLfile(String fileName)
           
 

Constructors in org.maltparser.core.io.dataformat that throw MaltChainedException
ColumnDescription(int position, String name, String category, String type, String defaultOutput, SymbolTableHandler symbolTables, String specialSymbolsfileName, String rootLabel)
           
DataFormatInstance(SortedMap<String,DataFormatEntry> entries, SymbolTableHandler symbolTables, String nullValueStrategy, String rootLabel, DataFormatSpecification spec)
           
DataFormatManager(String inputFormatName, String outputFormatName)
           
 

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 OptionManager.generateMaps()
          Creates several option maps for fast access to individual options.
 void OptionDescriptions.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, HashSet<String> excludeGroups)
          Returns a string representation of all option value, except the options in a option group specified by the excludeGroup argument.
 

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

Methods in org.maltparser.core.options.option that throw MaltChainedException
 void EnumOption.addLegalValue(String value)
          Adds a legal value without a description
 void EnumOption.addLegalValue(String value, String desc)
          Adds a legal value
 void StringEnumOption.addLegalValue(String value, String desc, String mapto)
          Adds a legal value that corresponds to another string
 void ClassOption.addLegalValue(String value, String desc, String classname)
          Adds a legal value that corresponds to a class
 Object UnaryOption.getDefaultValueObject()
           
 Object StringOption.getDefaultValueObject()
           
 Object StringEnumOption.getDefaultValueObject()
           
abstract  Object Option.getDefaultValueObject()
          Returns the object for the default value for option.
 Object IntegerOption.getDefaultValueObject()
           
 Object EnumOption.getDefaultValueObject()
           
 Object BoolOption.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 UnaryOption.getValueObject(String value)
           
 Object StringOption.getValueObject(String value)
           
 Object StringEnumOption.getValueObject(String value)
           
abstract  Object Option.getValueObject(String value)
          Returns the corresponding object for the option value (specified as a string value).
 Object IntegerOption.getValueObject(String value)
           
 Object EnumOption.getValueObject(String value)
           
 Object ClassOption.getValueObject(String value)
           
 Object BoolOption.getValueObject(String value)
           
 void UnaryOption.setDefaultValue(String defaultValue)
           
 void StringEnumOption.setDefaultValue(String defaultValue)
           
abstract  void Option.setDefaultValue(String defaultValue)
          Sets the default value for the option.
 void IntegerOption.setDefaultValue(String defaultValue)
           
 void EnumOption.setDefaultValue(String defaultValue)
           
 void ClassOption.setDefaultValue(String defaultValue)
           
 void BoolOption.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.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, int columnCategory, String nullValueStrategy, String rootLabel)
           
 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)
           
 SymbolTable SymbolTableHandler.loadTagset(String fileName, String tableName, String charSet, int columnCategory, String nullValueStrategy, String rootLabel)
           
 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 value)
           
 void TableFeature.setFeatureValue(String value)
           
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, int columnCategory, String nullValueStrategy, String rootLabel)
           
 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)
           
 SymbolTable TrieSymbolTableHandler.loadTagset(String fileName, String tableName, String charSet, int columnCategory, String nullValueStrategy, String rootLabel)
           
 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)
           
TrieSymbolTable(String name, Trie trie, int columnCategory, String nullValueStrategy, String rootLabel)
           
 

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

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
 int NumOfFeature.getCode(String symbol)
          Returns the integer representation of the string symbol according to the numof feature function.
 int InputArcFeature.getCode(String symbol)
           
 int InputArcDirFeature.getCode(String symbol)
           
 int ExistsFeature.getCode(String symbol)
          Returns the integer representation of the string symbol according to the exists feature function.
 int DistanceFeature.getCode(String symbol)
          Returns the integer representation of the string symbol according to the distance feature function.
 int ColumnFeature.getCode(String value)
           
 int ArcDirFeature.getCode(String symbol)
          Returns the integer representation of the string symbol according to the exists feature function.
 String NumOfFeature.getSymbol(int code)
          Returns the string representation of the integer code according to the numof feature function.
 String InputArcFeature.getSymbol(int code)
           
 String InputArcDirFeature.getSymbol(int code)
           
 String ExistsFeature.getSymbol(int code)
          Returns the string representation of the integer code according to the exists feature function.
 String DistanceFeature.getSymbol(int code)
          Returns the string representation of the integer code according to the distance feature function.
 String ColumnFeature.getSymbol(int value)
           
 String ArcDirFeature.getSymbol(int code)
          Returns the string representation of the integer code according to the exists feature function.
 void OutputTableFeature.initialize(Object[] arguments)
           
 void OutputColumnFeature.initialize(Object[] arguments)
           
 void NumOfFeature.initialize(Object[] arguments)
          Initialize the distance feature function
 void InputColumnFeature.initialize(Object[] arguments)
           
 void InputArcFeature.initialize(Object[] arguments)
           
 void InputArcDirFeature.initialize(Object[] arguments)
           
 void ExistsFeature.initialize(Object[] arguments)
          Initialize the exists feature function
 void DistanceFeature.initialize(Object[] arguments)
          Initialize the distance feature function
 void DGraphAddressFunction.initialize(Object[] arguments)
           
abstract  void ColumnFeature.initialize(Object[] arguments)
           
 void ArcDirFeature.initialize(Object[] arguments)
          Initialize the exists feature function
 void InputArcFeature.setColumn(ColumnDescription column)
           
 void InputArcDirFeature.setColumn(ColumnDescription column)
           
 void ColumnFeature.setFeatureValue(int value)
           
 void ColumnFeature.setFeatureValue(String value)
           
 void OutputTableFeature.update()
           
 void OutputColumnFeature.update()
           
 void NumOfFeature.update()
          Cause the feature function to update the feature value.
 void InputColumnFeature.update()
           
 void InputArcFeature.update()
           
 void InputArcDirFeature.update()
           
 void ExistsFeature.update()
          Cause the feature function to update the feature value.
 void DistanceFeature.update()
          Cause the feature function to update the feature value.
 void DGraphAddressFunction.update()
           
abstract  void ColumnFeature.update()
           
 void ArcDirFeature.update()
          Cause the feature function to update the feature value.
 void DGraphAddressFunction.update(Object[] arguments)
           
 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)
           
NumOfFeature(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 PrioList.getHeadChild(NonTerminalNode nt)
           
 PhraseStructureNode HeadRules.getHeadChild(NonTerminalNode nt)
           
 PhraseStructureNode HeadRule.getHeadChild(NonTerminalNode nt)
           
 PhraseStructureNode PrioSet.getHeadChild(NonTerminalNode nt, Direction direction)
           
 String PrioSetMember.getSymbolString()
           
 String HeadRule.getSymbolString()
           
 void PrioSet.init(String setSpec)
           
 void PrioList.init(String listSpec)
           
 void HeadRule.init(String ruleSpec)
           
 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 Root.addHeadEdgeLabel(LabelSet labelSet)
           
 void DependencyNode.addHeadEdgeLabel(LabelSet labelSet)
           
 void Token.addHeadEdgeLabel(SymbolTable table, int code)
           
 void Root.addHeadEdgeLabel(SymbolTable table, int code)
           
 void DependencyNode.addHeadEdgeLabel(SymbolTable table, int code)
           
 void Token.addHeadEdgeLabel(SymbolTable table, String symbol)
           
 void Root.addHeadEdgeLabel(SymbolTable table, String symbol)
           
 void DependencyNode.addHeadEdgeLabel(SymbolTable table, String symbol)
           
 void Token.addIncomingEdge(Edge in)
           
 void Root.addIncomingEdge(Edge in)
           
 void NonTerminal.addIncomingEdge(Edge in)
           
 void Node.addIncomingEdge(Edge in)
           
 void GraphNode.addIncomingEdge(Edge in)
           
 void Token.addOutgoingEdge(Edge out)
           
 void Root.addOutgoingEdge(Edge out)
           
 void NonTerminal.addOutgoingEdge(Edge out)
           
 void Node.addOutgoingEdge(Edge out)
           
 void GraphNode.addOutgoingEdge(Edge out)
           
 void Token.clear()
           
 void Root.clear()
           
 void NonTerminal.clear()
           
 void GraphNode.clear()
           
 DependencyNode Token.getAncestor()
           
 DependencyNode Root.getAncestor()
           
 DependencyNode DependencyNode.getAncestor()
           
 int Token.getDependencyNodeDepth()
           
 int Root.getDependencyNodeDepth()
           
 int DependencyNode.getDependencyNodeDepth()
          Returns the depth of the node.
 DependencyNode Token.getHead()
           
 DependencyNode Root.getHead()
           
 DependencyNode DependencyNode.getHead()
          Returns the head dependency node if it exists, otherwise null.
 PhraseStructureNode Root.getHeadChild()
           
 PhraseStructureNode NonTerminalNode.getHeadChild()
           
 PhraseStructureNode NonTerminal.getHeadChild()
           
 PhraseStructureNode Root.getHeadChild(HeadRules headRules)
           
 PhraseStructureNode NonTerminalNode.getHeadChild(HeadRules headRules)
           
 PhraseStructureNode NonTerminal.getHeadChild(HeadRules headRules)
           
 Edge Token.getHeadEdge()
           
 Edge Root.getHeadEdge()
           
 Edge DependencyNode.getHeadEdge()
          Returns the edge between the head and the node if it exists, otherwise null.
 int Token.getHeadEdgeLabelCode(SymbolTable table)
           
 int Root.getHeadEdgeLabelCode(SymbolTable table)
           
 int DependencyNode.getHeadEdgeLabelCode(SymbolTable table)
           
 LabelSet Token.getHeadEdgeLabelSet()
           
 LabelSet Root.getHeadEdgeLabelSet()
           
 LabelSet DependencyNode.getHeadEdgeLabelSet()
           
 String Token.getHeadEdgeLabelSymbol(SymbolTable table)
           
 String Root.getHeadEdgeLabelSymbol(SymbolTable table)
           
 String DependencyNode.getHeadEdgeLabelSymbol(SymbolTable table)
           
 Set<SymbolTable> Token.getHeadEdgeLabelTypes()
           
 Set<SymbolTable> Root.getHeadEdgeLabelTypes()
           
 Set<SymbolTable> DependencyNode.getHeadEdgeLabelTypes()
           
 Set<Edge> Token.getHeadEdges()
           
 Set<Edge> Root.getHeadEdges()
           
 Set<Edge> DependencyNode.getHeadEdges()
           
 Set<DependencyNode> Token.getHeads()
           
 Set<DependencyNode> Root.getHeads()
           
 Set<DependencyNode> DependencyNode.getHeads()
           
 ComparableNode Token.getLeftmostDescendant()
           
 ComparableNode Root.getLeftmostDescendant()
           
 ComparableNode NonTerminal.getLeftmostDescendant()
           
 ComparableNode ComparableNode.getLeftmostDescendant()
          Returns the left-most terminal descendant node.
 int GraphNode.getLeftmostDescendantIndex()
           
 int ComparableNode.getLeftmostDescendantIndex()
          Returns the index of the left-most terminal descendant node.
 ComparableNode Token.getLeftmostProperDescendant()
           
 ComparableNode Root.getLeftmostProperDescendant()
           
 ComparableNode ComparableNode.getLeftmostProperDescendant()
          Returns the left-most proper terminal descendant node (excluding itself).
 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 Root.getLeftSibling()
          Returns the left sibling if it exists, otherwise null
 DependencyNode DependencyNode.getLeftSibling()
          Returns the left sibling if it exists, otherwise null
 TokenNode Root.getLexicalHead()
           
 TokenNode NonTerminalNode.getLexicalHead()
           
 TokenNode NonTerminal.getLexicalHead()
           
 TokenNode Root.getLexicalHead(HeadRules headRules)
           
 TokenNode NonTerminalNode.getLexicalHead(HeadRules headRules)
           
 TokenNode NonTerminal.getLexicalHead(HeadRules headRules)
           
 Edge Token.getParentEdge()
           
 Edge Root.getParentEdge()
           
 Edge PhraseStructureNode.getParentEdge()
           
 Edge NonTerminal.getParentEdge()
           
 int Token.getParentEdgeLabelCode(SymbolTable table)
           
 int Root.getParentEdgeLabelCode(SymbolTable table)
           
 int PhraseStructureNode.getParentEdgeLabelCode(SymbolTable table)
           
 int NonTerminal.getParentEdgeLabelCode(SymbolTable table)
           
 String Token.getParentEdgeLabelSymbol(SymbolTable table)
           
 String Root.getParentEdgeLabelSymbol(SymbolTable table)
           
 String PhraseStructureNode.getParentEdgeLabelSymbol(SymbolTable table)
           
 String NonTerminal.getParentEdgeLabelSymbol(SymbolTable table)
           
 DependencyNode Token.getProperAncestor()
           
 DependencyNode Root.getProperAncestor()
           
 DependencyNode DependencyNode.getProperAncestor()
           
 ComparableNode Token.getRightmostDescendant()
           
 ComparableNode Root.getRightmostDescendant()
           
 ComparableNode NonTerminal.getRightmostDescendant()
           
 ComparableNode ComparableNode.getRightmostDescendant()
          Returns the right-most terminal descendant node.
 int GraphNode.getRightmostDescendantIndex()
           
 int ComparableNode.getRightmostDescendantIndex()
          Returns the index of the right-most terminal descendant node.
 ComparableNode Token.getRightmostProperDescendant()
           
 ComparableNode Root.getRightmostProperDescendant()
           
 ComparableNode ComparableNode.getRightmostProperDescendant()
          Returns the right-most proper terminal descendant node (excluding itself).
 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 Root.getRightSibling()
          Returns the right sibling if it exists, otherwise null
 DependencyNode DependencyNode.getRightSibling()
          Returns the right sibling if it exists, otherwise null
 DependencyNode Token.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 DependencyNode.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 Root.getSameSideRightSibling()
          Returns the right sibling at the same side of head as the node it self.
 DependencyNode DependencyNode.getSameSideRightSibling()
          Returns the right sibling at the same side of head as the node it self.
 boolean Token.hasAncestorInside(int left, int right)
           
 boolean Root.hasAncestorInside(int left, int right)
           
 boolean DependencyNode.hasAncestorInside(int left, int right)
           
 boolean Token.hasHeadEdgeLabel(SymbolTable table)
           
 boolean Root.hasHeadEdgeLabel(SymbolTable table)
           
 boolean DependencyNode.hasHeadEdgeLabel(SymbolTable table)
           
 boolean Token.hasParentEdgeLabel(SymbolTable table)
           
 boolean Root.hasParentEdgeLabel(SymbolTable table)
           
 boolean PhraseStructureNode.hasParentEdgeLabel(SymbolTable table)
           
 boolean NonTerminal.hasParentEdgeLabel(SymbolTable table)
           
 TokenNode Root.identifyHead(HeadRules headRules)
           
 TokenNode NonTerminalNode.identifyHead(HeadRules headRules)
           
 TokenNode NonTerminal.identifyHead(HeadRules headRules)
           
 boolean Token.isHeadEdgeLabeled()
           
 boolean Root.isHeadEdgeLabeled()
           
 boolean DependencyNode.isHeadEdgeLabeled()
           
 boolean Token.isProjective()
           
 boolean Root.isProjective()
           
 boolean DependencyNode.isProjective()
          Returns true if the head edge is projective, otherwise false.
 int Token.nHeadEdgeLabels()
           
 int Root.nHeadEdgeLabels()
           
 int DependencyNode.nHeadEdgeLabels()
           
 void Token.removeIncomingEdge(Edge in)
           
 void NonTerminal.removeIncomingEdge(Edge in)
           
 void Node.removeIncomingEdge(Edge in)
           
 void GraphNode.removeIncomingEdge(Edge in)
           
 void Token.removeOutgoingEdge(Edge out)
           
 void Root.removeOutgoingEdge(Edge out)
           
 void NonTerminal.removeOutgoingEdge(Edge out)
           
 void Node.removeOutgoingEdge(Edge out)
           
 void GraphNode.removeOutgoingEdge(Edge out)
           
 void Token.setIndex(int index)
           
 void Root.setIndex(int index)
           
 void NonTerminal.setIndex(int index)
           
 void Node.setIndex(int index)
           
abstract  void GraphNode.setIndex(int index)
           
 

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

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

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

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

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

Subclasses of MaltChainedException in org.maltparser.ml.liblinear
 class LiblinearException
          LiblinearException extends the MaltChainedException class and is thrown by classes within the libsvm package.
 

Methods in org.maltparser.ml.liblinear that throw MaltChainedException
 void Liblinear.addInstance(SingleDecision decision, FeatureVector featureVector)
           
protected  void Liblinear.closeInstanceWriter()
           
 void Liblinear.finalizeSentence(DependencyStructure dependencyGraph)
           
 double Liblinear.getBias()
           
 DependencyParserConfig Liblinear.getConfiguration()
          Returns the current configuration
protected  File Liblinear.getFile(String suffix)
           
protected  InputStreamReader Liblinear.getInstanceInputStreamReader(String suffix)
           
protected  OutputStreamWriter Liblinear.getInstanceOutputStreamWriter(String suffix)
           
 liblinear.Parameter Liblinear.getLiblinearParameters()
           
protected  void Liblinear.initSpecialParameters()
           
 void Liblinear.liblinear_predict_with_kbestlist(liblinear.Model model, liblinear.FeatureNode[] x, KBestList kBestList)
           
static void Liblinear.maltSVMFormat2OriginalSVMFormat(InputStreamReader isr, OutputStreamWriter osw, int[] cardinalities)
          Converts the instance file (Malt's own SVM format) into the Liblinear (SVMLight) format.
 void Liblinear.moveAllInstances(LearningMethod method, FeatureFunction divideFeature, ArrayList<Integer> divideFeatureIndexVector)
           
 void Liblinear.noMoreInstances()
           
 void Liblinear.parseParameters(String paramstring)
           
 boolean Liblinear.predict(FeatureVector featureVector, SingleDecision decision)
           
 liblinear.Problem Liblinear.readLibLinearProblem(InputStreamReader isr, int[] cardinalities)
          Reads an instance file into a svm_problem object according to the Malt-SVM format, which is column fixed format (tab-separated).
 void Liblinear.setLearnerMode(int learnerMode)
           
 void Liblinear.terminate()
           
 void Liblinear.train(FeatureVector featureVector)
           
 

Constructors in org.maltparser.ml.liblinear that throw MaltChainedException
Liblinear(InstanceModel owner, Integer learnerMode)
          Constructs a Liblinear learner.
 

Uses of MaltChainedException in org.maltparser.ml.libsvm
 

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

Methods in org.maltparser.ml.libsvm that throw MaltChainedException
 void Libsvm.addInstance(SingleDecision decision, FeatureVector featureVector)
           
protected  void Libsvm.closeInstanceWriter()
           
 void Libsvm.finalizeSentence(DependencyStructure dependencyGraph)
           
 DependencyParserConfig Libsvm.getConfiguration()
          Returns the current configuration
protected  File Libsvm.getFile(String suffix)
           
protected  InputStreamReader Libsvm.getInstanceInputStreamReader(String suffix)
           
protected  OutputStreamWriter Libsvm.getInstanceOutputStreamWriter(String suffix)
           
protected  void Libsvm.initParameters(libsvm.svm_parameter param)
          Assign a default value to all svm parameters
protected  void Libsvm.initSpecialParameters()
           
protected  void Libsvm.initSvmParam(String paramString)
          Initialize the LIBSVM according to the parameter string
static void Libsvm.maltSVMFormat2OriginalSVMFormat(InputStreamReader isr, OutputStreamWriter osw, int[] cardinalities)
          Converts the instance file (Malt's own SVM format) into the LIBSVM (SVMLight) format.
 void Libsvm.moveAllInstances(LearningMethod method, FeatureFunction divideFeature, ArrayList<Integer> divideFeatureIndexVector)
           
 void Libsvm.noMoreInstances()
           
 void Libsvm.parseParameters(String paramstring, libsvm.svm_parameter param)
          Parses the parameter string.
 boolean Libsvm.predict(FeatureVector featureVector, SingleDecision decision)
           
 libsvm.svm_problem Libsvm.readProblemMaltSVMFormat(InputStreamReader isr, int[] cardinalities, libsvm.svm_parameter param)
          Reads an instance file into a svm_problem object according to the Malt-SVM format, which is column fixed format (tab-separated).
 void Libsvm.setLearnerMode(int learnerMode)
           
 void Libsvm.svm_predict_with_kbestlist(libsvm.svm_model model, libsvm.svm_node[] x, KBestList kBestList)
           
 void Libsvm.terminate()
           
 void Libsvm.train(FeatureVector featureVector)
           
 

Constructors in org.maltparser.ml.libsvm that throw MaltChainedException
Libsvm(InstanceModel owner, Integer learnerMode)
          Constructs a LIBSVM learner.
 

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(org.maltparser.parser.transition.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.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)
           
 void Oracle.initActionContainers()
           
 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 SingleMalt.oracleParse(DependencyStructure goldGraph, DependencyStructure oracleGraph)
           
 void DependencyParserConfig.oracleParse(DependencyStructure goldGraph, DependencyStructure oracleGraph)
           
 void SingleMalt.parse(DependencyStructure graph)
           
abstract  DependencyStructure Parser.parse(DependencyStructure parseDependencyGraph)
          Parses the empty dependency graph
 DependencyStructure DeterministicParser.parse(DependencyStructure parseDependencyGraph)
           
 void DependencyParserConfig.parse(DependencyStructure 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()
           
 void DeterministicParser.terminate()
           
 void BatchTrainer.terminate()
           
abstract  void Algorithm.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(org.maltparser.parser.transition.TransitionTable ttable)
           
protected  void NonProjective.addAvailableTransitionToTable(org.maltparser.parser.transition.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 ArcStandard.addAvailableTransitionToTable(org.maltparser.parser.transition.TransitionTable ttable)
           
protected  void ArcEager.addAvailableTransitionToTable(org.maltparser.parser.transition.TransitionTable ttable)
           
 void ArcStandard.apply(GuideUserAction currentAction, ParserConfiguration config)
           
 void ArcEager.apply(GuideUserAction currentAction, ParserConfiguration config)
           
 void NivreConfig.clear()
           
 GuideUserAction ArcStandard.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 GuideUserAction ArcEager.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 void ArcStandardOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 void ArcEagerOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 GuideUserAction ArcStandard.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 GuideUserAction ArcEager.getDeterministicAction(GuideUserHistory history, ParserConfiguration config)
           
 DependencyNode NivreConfig.getInputNode(int index)
           
 DependencyNode NivreConfig.getStackNode(int index)
           
 void NivreAddressFunction.initialize(Object[] arguments)
           
 void NivreConfig.initialize(ParserConfiguration parserConfiguration)
           
protected  void ArcStandard.initWithDefaultTransitions(GuideUserHistory history)
           
protected  void ArcEager.initWithDefaultTransitions(GuideUserHistory history)
           
 Function NivreFactory.makeFunction(String subFunctionName)
           
 OracleGuide NivreArcStandardFactory.makeOracleGuide(GuideUserHistory history)
           
 OracleGuide NivreArcEagerFactory.makeOracleGuide(GuideUserHistory history)
           
 ParserConfiguration NivreFactory.makeParserConfiguration()
           
 TransitionSystem NivreArcStandardFactory.makeTransitionSystem()
           
 TransitionSystem NivreArcEagerFactory.makeTransitionSystem()
           
 boolean ArcStandard.permissible(GuideUserAction currentAction, ParserConfiguration config)
           
 boolean ArcEager.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.stack
 

Methods in org.maltparser.parser.algorithm.stack that throw MaltChainedException
protected  void Projective.addAvailableTransitionToTable(org.maltparser.parser.transition.TransitionTable ttable)
           
protected  void NonProjective.addAvailableTransitionToTable(org.maltparser.parser.transition.TransitionTable ttable)
           
 void Projective.apply(GuideUserAction currentAction, ParserConfiguration configuration)
           
 void NonProjective.apply(GuideUserAction currentAction, ParserConfiguration configuration)
           
 void StackConfig.clear()
           
 GuideUserAction Projective.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 GuideUserAction NonProjective.defaultAction(GuideUserHistory history, ParserConfiguration configuration)
           
 void SwapLazyOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 void SwapEagerOracle.finalizeSentence(DependencyStructure dependencyGraph)
           
 void ProjectiveOracle.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 SwapLazyOracle.predict(DependencyStructure gold, ParserConfiguration configuration)
           
 GuideUserAction SwapEagerOracle.predict(DependencyStructure gold, ParserConfiguration configuration)
           
 GuideUserAction ProjectiveOracle.predict(DependencyStructure gold, ParserConfiguration configuration)
           
 void StackConfig.setDependencyGraph(DependencyStructure source)
           
 void SwapLazyOracle.terminate()
           
 void SwapEagerOracle.terminate()
           
 void ProjectiveOracle.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.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 SingleGuide.addInstance(GuideDecision decision)
           
 void ClassifierGuide.addInstance(GuideDecision decision)
           
 FeatureVector SingleGuide.extract()
           
 FeatureVector ClassifierGuide.extract()
           
 void SingleGuide.finalizeSentence(DependencyStructure dependencyGraph)
           
 void Model.finalizeSentence(DependencyStructure dependencyGraph)
           
 void Guide.finalizeSentence(DependencyStructure dependencyGraph)
           
 String Model.getModelName()
           
protected  void SingleGuide.initDecisionModel(SingleDecision decision)
           
protected  void SingleGuide.initFeatureModel()
           
protected  void SingleGuide.initFeatureModelManager()
           
protected  void SingleGuide.initHistory()
           
 void SingleGuide.noMoreInstances()
           
 void Model.noMoreInstances()
           
 void ClassifierGuide.noMoreInstances()
           
 GuideUserAction OracleGuide.predict(DependencyStructure gold, ParserConfiguration config)
           
 void SingleGuide.predict(GuideDecision decision)
           
 void ClassifierGuide.predict(GuideDecision decision)
           
 void Guidable.predict(GuideUserAction action)
           
 FeatureVector SingleGuide.predictExtract(GuideDecision decision)
           
 FeatureVector ClassifierGuide.predictExtract(GuideDecision decision)
           
 boolean SingleGuide.predictFromKBestList(GuideDecision decision)
           
 boolean ClassifierGuide.predictFromKBestList(GuideDecision decision)
           
 boolean Guidable.predictFromKBestList(GuideUserAction action)
           
 void Guidable.setInstance(GuideUserAction action)
           
 void SingleGuide.terminate()
           
 void Model.terminate()
           
 void Guide.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 SeqDecisionModel.addInstance(GuideDecision decision)
           
 void OneDecisionModel.addInstance(GuideDecision decision)
           
 void DecisionModel.addInstance(GuideDecision decision)
           
 void BranchedDecisionModel.addInstance(GuideDecision decision)
           
 FeatureVector SeqDecisionModel.extract()
           
 FeatureVector OneDecisionModel.extract()
           
 FeatureVector DecisionModel.extract()
           
 FeatureVector BranchedDecisionModel.extract()
           
 void SeqDecisionModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 void OneDecisionModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 void BranchedDecisionModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 void SeqDecisionModel.noMoreInstances()
           
 void OneDecisionModel.noMoreInstances()
           
 void BranchedDecisionModel.noMoreInstances()
           
 boolean SeqDecisionModel.predict(GuideDecision decision)
           
 boolean OneDecisionModel.predict(GuideDecision decision)
           
 boolean DecisionModel.predict(GuideDecision decision)
           
 boolean BranchedDecisionModel.predict(GuideDecision decision)
           
 FeatureVector SeqDecisionModel.predictExtract(GuideDecision decision)
           
 FeatureVector OneDecisionModel.predictExtract(GuideDecision decision)
           
 FeatureVector DecisionModel.predictExtract(GuideDecision decision)
           
 FeatureVector BranchedDecisionModel.predictExtract(GuideDecision decision)
           
 boolean SeqDecisionModel.predictFromKBestList(GuideDecision decision)
           
 boolean OneDecisionModel.predictFromKBestList(GuideDecision decision)
           
 boolean DecisionModel.predictFromKBestList(GuideDecision decision)
           
 boolean BranchedDecisionModel.predictFromKBestList(GuideDecision decision)
           
 void SeqDecisionModel.terminate()
           
 void OneDecisionModel.terminate()
           
 void BranchedDecisionModel.terminate()
           
 void SeqDecisionModel.updateCardinality()
           
 void OneDecisionModel.updateCardinality()
           
 void DecisionModel.updateCardinality()
           
 void BranchedDecisionModel.updateCardinality()
           
 void SeqDecisionModel.updateFeatureModel()
           
 void OneDecisionModel.updateFeatureModel()
           
 void DecisionModel.updateFeatureModel()
           
 void BranchedDecisionModel.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 InstanceModel.addInstance(SingleDecision decision)
           
 void FeatureDivideModel.addInstance(SingleDecision decision)
           
 void AtomicModel.addInstance(SingleDecision decision)
           
 FeatureVector InstanceModel.extract()
           
 FeatureVector FeatureDivideModel.extract()
           
 FeatureVector AtomicModel.extract()
           
 void FeatureDivideModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 void AtomicModel.finalizeSentence(DependencyStructure dependencyGraph)
           
 String FeatureDivideModel.getModelName()
           
 Model AtomicModel.getParent()
          Returns the parent guide model
 void AtomicModel.initMethod()
          Initialize the learning method according to the option --learner-method.
protected  void FeatureDivideModel.initSplitParam(FeatureVector featureVector)
          Initialize the feature split parameters and the split feature vector and master feature vector according to the behavior strategy.
protected  void FeatureDivideModel.load()
          Loads the feature divide model settings .fsm file.
 void AtomicModel.moveAllInstances(AtomicModel model, FeatureFunction divideFeature, ArrayList<Integer> divideFeatureIndexVector)
          Moves all instance from this atomic model into the destination atomic model and add the divide feature.
 void FeatureDivideModel.noMoreInstances()
           
 void AtomicModel.noMoreInstances()
           
 boolean InstanceModel.predict(SingleDecision decision)
           
 boolean FeatureDivideModel.predict(SingleDecision decision)
           
 boolean AtomicModel.predict(SingleDecision decision)
           
 FeatureVector InstanceModel.predictExtract(SingleDecision decision)
           
 FeatureVector FeatureDivideModel.predictExtract(SingleDecision decision)
           
 FeatureVector AtomicModel.predictExtract(SingleDecision decision)
           
protected  void FeatureDivideModel.save()
          Saves the feature divide model settings .fsm file.
protected  void FeatureDivideModel.setParent(Model parent)
          Sets the parent model
 void FeatureDivideModel.terminate()
           
 void AtomicModel.terminate()
           
 void InstanceModel.train()
           
 void FeatureDivideModel.train()
           
 void AtomicModel.train()
          Invokes the train() of the learning method
 

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

Uses of MaltChainedException in org.maltparser.parser.history
 

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

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

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

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

Methods in org.maltparser.parser.history.action that throw MaltChainedException
 void GuideUserAction.addAction(ActionContainer[] actionContainers)
           
 void ComplexDecisionAction.addAction(ActionContainer[] actionContainers)
           
 void GuideUserAction.addAction(ArrayList<ActionContainer> actionContainers)
           
 void ComplexDecisionAction.addAction(ArrayList<ActionContainer> actionContainers)
           
 void 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 GuideUserAction.getAction(ActionContainer[] actionContainers)
           
 void ComplexDecisionAction.getAction(ActionContainer[] actionContainers)
           
 void GuideUserAction.getAction(ArrayList<ActionContainer> actionContainers)
           
 void ComplexDecisionAction.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 GuideUserAction.getKBestLists(ArrayList<ScoredKBestList> kbestListContainers)
           
 void ComplexDecisionAction.getKBestLists(ArrayList<ScoredKBestList> kbestListContainers)
           
 void GuideUserAction.getKBestLists(ScoredKBestList[] kbestListContainers)
           
 void ComplexDecisionAction.getKBestLists(ScoredKBestList[] kbestListContainers)
           
 SingleDecision MultipleDecision.getSingleDecision(int decisionIndex)
           
 SingleDecision ComplexDecisionAction.getSingleDecision(int decisionIndex)
           
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)
           
 boolean KBestList.updateActionWithNextKBest()
          Updates the corresponding single decision with the next value in the k-best list.
 

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, SymbolTableHandler symbolTables)
           
 void PseudoProjectivity.mergeArclabels(DependencyStructure pdg)
           
 int PseudoProjChartItem.postprocess(int signal)
           
 int PseudoProjChartItem.preprocess(int signal)
           
 int PseudoProjChartItem.process(int signal)
           
 void PseudoProjectivity.projectivize(DependencyStructure pdg)
           
 void PseudoProjectivity.splitArclabels(DependencyStructure pdg)
           
 void PseudoProjChartItem.terminate()
           
 


MaltParser 1.3

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