/// <summary> /// Returns a string representation of the option value for the specified option. It uses the priority /// amongst the internal option containers. /// </summary> /// <param name="option"> the option object </param> /// <returns> a string representation of the option value </returns> public virtual string getOptionValueString(Option.Option option) { string value = null; for (int i = SAVEDOPTION; i <= OPTIONFILE; i++) { if (i == SAVEDOPTION) { value = option.getStringRepresentation(savedOptionMap[option]); } else if (i == DEPENDENCIES_RESOLVED) { value = option.getStringRepresentation(dependenciesResolvedOptionMap[option]); } else if (i == COMMANDLINE) { value = option.getStringRepresentation(commandLineOptionMap[option]); } else if (i == OPTIONFILE) { value = option.getStringRepresentation(optionFileOptionMap[option]); } if (!ReferenceEquals(value, null)) { return(value); } } return(null); }
/// <summary> /// Returns the option value object for the option. It uses the priority amongst the internal /// option containers. /// </summary> /// <param name="option"> the option object </param> /// <returns> the option value object </returns> public virtual object getOptionValue(Option.Option option) { object value = null; for (int i = SAVEDOPTION; i <= OPTIONFILE; i++) { if (i == SAVEDOPTION) { value = savedOptionMap[option]; } else if (i == DEPENDENCIES_RESOLVED) { value = dependenciesResolvedOptionMap[option]; } else if (i == COMMANDLINE) { value = commandLineOptionMap[option]; } else if (i == OPTIONFILE) { value = optionFileOptionMap[option]; } if (value != null) { return(value); } } return(null); }
/// <summary> /// Returns an option based on the option flag /// </summary> /// <param name="optionflag"> the option flag </param> /// <returns> an option based on the option flag </returns> /// <exception cref="MaltChainedException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public org.maltparser.core.options.option.Option getOption(String optionflag) throws org.maltparser.core.exception.MaltChainedException public virtual Option.Option getOption(string optionflag) { Option.Option option = flagOptionMap[optionflag]; if (option == null) { throw new OptionException("The option flag -" + optionflag + " could not be found. "); } return(option); }
/// <summary> /// Returns a string representation of the option value for an option that is in a specific option container. /// </summary> /// <param name="containerIndex"> the index of the option container. </param> /// <param name="option"> an option object </param> /// <returns> a string representation of the option value for an option that is in a specific option container. </returns> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public String getOptionValueString(int containerIndex, org.maltparser.core.options.option.Option option) throws OptionException public virtual string getOptionValueString(int containerIndex, Option.Option option) { OptionContainer oc = optionContainers[containerIndex]; if (oc == null) { throw new OptionException("The option container '" + containerIndex + "' cannot be found. "); } return(oc.getOptionValueString(option)); }
/// <summary> /// Returns the option value for an option. /// </summary> /// <param name="option"> an option object /// @return the option value for an option, <i>null</i> if the option value could not be found. </param> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public Object getOptionValue(org.maltparser.core.options.option.Option option) throws OptionException public virtual object getOptionValue(Option.Option option) { if (optionContainers.Count == 0) { return(null); } OptionContainer oc = optionContainers[optionContainers.firstKey()]; return(oc.getOptionValue(option)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public Object getOptionValueNoDefault(int containerIndex, String optiongroup, String optionname) throws org.maltparser.core.exception.MaltChainedException public virtual object getOptionValueNoDefault(int containerIndex, string optiongroup, string optionname) { Option.Option option = optionDescriptions.getOption(optiongroup, optionname); if (containerIndex == DEFAULTVALUE) { return(option.DefaultValueObject); } return(optionValues.getOptionValue(containerIndex, option)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void overloadOptionValue(int containerIndex, int containerType, String optiongroup, String optionname, String value) throws org.maltparser.core.exception.MaltChainedException public virtual void overloadOptionValue(int containerIndex, int containerType, string optiongroup, string optionname, string value) { Option.Option option = optionDescriptions.getOption(optiongroup, optionname); if (ReferenceEquals(value, null)) { throw new OptionException("The option value is missing. "); } object ovalue = option.getValueObject(value); optionValues.addOptionValue(containerType, containerIndex, option, ovalue); }
/// <summary> /// Returns a string representation of the option value for an option that is specified by the option group name and the option name. The /// container name points out the specific option container. /// </summary> /// <param name="containerIndex"> The index of the option container (0..n and -1 is default values). </param> /// <param name="optiongroup"> The name of the option group. </param> /// <param name="optionname"> The name of the option. </param> /// <returns> a string representation of the option value </returns> /// <exception cref="MaltChainedException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public String getOptionValueString(int containerIndex, String optiongroup, String optionname) throws org.maltparser.core.exception.MaltChainedException public virtual string getOptionValueString(int containerIndex, string optiongroup, string optionname) { Option.Option option = optionDescriptions.getOption(optiongroup, optionname); string value = optionValues.getOptionValueString(containerIndex, option); if (ReferenceEquals(value, null)) { value = option.DefaultValueString; } return(value); }
/// <summary> /// Creates several option maps for fast access to individual options. /// </summary> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void generateMaps() throws org.maltparser.core.exception.MaltChainedException public virtual void generateMaps() { foreach (string groupname in optionGroups.Keys) { OptionGroup og = optionGroups[groupname]; ICollection <Option.Option> options = og.OptionList; foreach (Option.Option option in options) { if (ambiguous.Contains(option.Name)) { option.Ambiguous = true; ambiguousOptionMap[option.Group.Name + "-" + option.Name] = option; } else { if (!unambiguousOptionMap.ContainsKey(option.Name)) { unambiguousOptionMap[option.Name] = option; } else { Option.Option ambig = unambiguousOptionMap[option.Name]; unambiguousOptionMap.Remove(ambig); ambig.Ambiguous = true; option.Ambiguous = true; ambiguous.Add(option.Name); ambiguousOptionMap[ambig.Group.Name + "-" + ambig.Name] = ambig; ambiguousOptionMap[option.Group.Name + "-" + option.Name] = option; } } if (!ReferenceEquals(option.Flag, null)) { Option.Option co = flagOptionMap[option.Flag]; if (co != null) { flagOptionMap.Remove(co); co.Flag = null; option.Flag = null; if (SystemLogger.logger().DebugEnabled) { SystemLogger.logger().debug("Ambiguous use of an option flag -> the option flag is removed for all ambiguous options\n"); } } else { flagOptionMap[option.Flag] = option; } } } } }
/// <summary> /// Sets the name of the option group /// </summary> /// <param name="name"> the name of the option group </param> // public void setName(String name) { // this.name = name.toLowerCase(); // } /// <summary> /// Adds an option to the option group. /// </summary> /// <param name="option"> an option </param> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void addOption(org.maltparser.core.options.option.Option option) throws OptionException public virtual void addOption(Option.Option option) { if (ReferenceEquals(option.Name, null) || option.Name.Equals("")) { throw new OptionException("The option name is null or contains the empty string. "); } else if (options.ContainsKey(option.Name.ToLower())) { throw new OptionException("The option name already exists for that option group. "); } else { options[option.Name.ToLower()] = option; } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void addLegalValue(String optiongroup, String optionname, String value, String desc, String target) throws org.maltparser.core.exception.MaltChainedException public virtual void addLegalValue(string optiongroup, string optionname, string value, string desc, string target) { Option.Option option = optionDescriptions.getOption(optiongroup, optionname); if (option != null) { if (option is EnumOption) { ((EnumOption)option).addLegalValue(value, desc); } else if (option is ClassOption) { ((ClassOption)option).addLegalValue(value, desc, target); } else if (option is StringEnumOption) { ((StringEnumOption)option).addLegalValue(value, desc, target); } } }
/// <summary> /// Parses an option container for option values. /// </summary> /// <param name="container"> a reference to an individual option container in the DOM tree. </param> /// <param name="containerName"> the name of this container. </param> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void parseOptionValues(org.w3c.dom.Element container, int containerIndex) throws org.maltparser.core.exception.MaltChainedException private void parseOptionValues(Element container, int containerIndex) { NodeList optiongroups = container.getElementsByTagName("optiongroup"); Element optiongroup; for (int i = 0; i < optiongroups.Length; i++) { optiongroup = (Element)optiongroups.item(i); string groupname = optiongroup.getAttribute("groupname").ToLower(); if (ReferenceEquals(groupname, null)) { throw new OptionException("The option group name is missing. "); } NodeList optionvalues = optiongroup.getElementsByTagName("option"); Element optionvalue; for (int j = 0; j < optionvalues.Length; j++) { optionvalue = (Element)optionvalues.item(j); string optionname = optionvalue.getAttribute("name").ToLower(); string value = optionvalue.getAttribute("value"); if (ReferenceEquals(optionname, null)) { throw new OptionException("The option name is missing. "); } Option.Option option = optionDescriptions.getOption(groupname, optionname); if (option is UnaryOption) { value = "used"; } if (ReferenceEquals(value, null)) { throw new OptionException("The option value is missing. "); } object ovalue = option.getValueObject(value); optionValues.addOptionValue(OptionContainer.OPTIONFILE, containerIndex, option, ovalue); } } }
/// <summary> /// Adds an option value to an option to one of the internal option container specified by the type. /// </summary> /// <param name="type"> the internal option container </param> /// <param name="option"> the option object </param> /// <param name="value"> the option value object </param> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: protected void addOptionValue(int type, org.maltparser.core.options.option.Option option, Object value) throws OptionException protected internal virtual void addOptionValue(int type, Option.Option option, object value) { if (type == SAVEDOPTION) { savedOptionMap[option] = value; } else if (type == DEPENDENCIES_RESOLVED) { dependenciesResolvedOptionMap[option] = value; } else if (type == COMMANDLINE) { commandLineOptionMap[option] = value; } else if (type == OPTIONFILE) { optionFileOptionMap[option] = value; } else { throw new OptionException("Unknown option container type"); } }
/// <summary> /// Returns true if the option is present in the specified internal option container, otherwise false. /// </summary> /// <param name="type"> the internal option container </param> /// <param name="option"> the option object </param> /// <returns> true if the option is present in the specified internal option container, otherwise false </returns> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public boolean contains(int type, org.maltparser.core.options.option.Option option) throws OptionException public virtual bool contains(int type, Option.Option option) { if (type == SAVEDOPTION) { return(savedOptionMap.ContainsValue(option)); } else if (type == DEPENDENCIES_RESOLVED) { return(dependenciesResolvedOptionMap.ContainsValue(option)); } else if (type == COMMANDLINE) { return(commandLineOptionMap.ContainsValue(option)); } else if (type == OPTIONFILE) { return(optionFileOptionMap.ContainsValue(option)); } else { throw new OptionException("Unknown option container type"); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public Object getOptionDefaultValue(String optiongroup, String optionname) throws org.maltparser.core.exception.MaltChainedException public virtual object getOptionDefaultValue(string optiongroup, string optionname) { Option.Option option = optionDescriptions.getOption(optiongroup, optionname); return(option.DefaultValueObject); }
/// <summary> /// Loads the saved options (options that are marked with <code>usage=Option.SAVE</code>). /// </summary> /// <param name="isr"> the input stream reader of the saved options file. </param> /// <exception cref="MaltChainedException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void loadOptions(int containerIndex, java.io.InputStreamReader isr) throws org.maltparser.core.exception.MaltChainedException public virtual void loadOptions(int containerIndex, StreamReader isr) { try { StreamReader br = new StreamReader(isr); string line = null; Option.Option option = null; Pattern tabPattern = Pattern.compile("\t"); while (!ReferenceEquals((line = br.ReadLine()), null)) { string[] items = tabPattern.split(line); if (items.Length < 3 || items.Length > 4) { throw new OptionException("Could not load the saved option. "); } option = optionDescriptions.getOption(items[1], items[2]); object ovalue; if (items.Length == 3) { ovalue = ""; } else { if (option is ClassOption) { if (items[3].StartsWith("class ", StringComparison.Ordinal)) { Type clazz = null; if (PluginLoader.instance() != null) { clazz = PluginLoader.instance().getClass(items[3].Substring(6)); } if (clazz == null) { clazz = Type.GetType(items[3].Substring(6)); } ovalue = option.getValueObject(((ClassOption)option).getLegalValueString(clazz)); } else { ovalue = option.getValueObject(items[3]); } } else { ovalue = option.getValueObject(items[3]); } } optionValues.addOptionValue(OptionContainer.SAVEDOPTION, containerIndex, option, ovalue); } br.Close(); } catch (ClassNotFoundException e) { throw new OptionException("The class cannot be found. ", e); } catch (FormatException e) { throw new OptionException("Option container index isn't an integer value. ", e); } catch (IOException e) { throw new OptionException("Error when reading the saved options. ", e); } }
/// <summary> /// Parses the command line arguments. /// </summary> /// <param name="args"> An array of arguments that are supplied when starting the application. </param> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public boolean parseCommandLine(String[] args, int containerIndex) throws org.maltparser.core.exception.MaltChainedException public virtual bool parseCommandLine(string[] args, int containerIndex) { if (args == null || args.Length == 0) { return(false); } int i = 0; Dictionary <string, string> oldFlags = new Dictionary <string, string>(); oldFlags["llo"] = "lo"; oldFlags["lso"] = "lo"; oldFlags["lli"] = "li"; oldFlags["lsi"] = "li"; oldFlags["llx"] = "lx"; oldFlags["lsx"] = "lx"; oldFlags["llv"] = "lv"; oldFlags["lsv"] = "lv"; while (i < args.Length) { Option.Option option = null; string value = null; /* Recognizes * --optiongroup-optionname=value * --optionname=value * --optiongroup-optionname (unary option) * --optionname (unary option) */ if (args[i].StartsWith("--", StringComparison.Ordinal)) { if (args[i].Length == 2) { throw new OptionException("The argument contains only '--', please check the user guide to see the correct format. "); } string optionstring; string optiongroup; string optionname; int indexEqualSign = args[i].IndexOf('='); if (indexEqualSign != -1) { value = args[i].Substring(indexEqualSign + 1); optionstring = args[i].Substring(2, indexEqualSign - 2); } else { value = null; optionstring = args[i].Substring(2); } int indexMinusSign = optionstring.IndexOf('-'); if (indexMinusSign != -1) { optionname = optionstring.Substring(indexMinusSign + 1); optiongroup = optionstring.Substring(0, indexMinusSign); } else { optiongroup = null; optionname = optionstring; } option = optionDescriptions.getOption(optiongroup, optionname); if (option is UnaryOption) { value = "used"; } i++; } /* Recognizes * -optionflag value * -optionflag (unary option) */ else if (args[i].StartsWith("-", StringComparison.Ordinal)) { if (args[i].Length < 2) { throw new OptionException("Wrong use of option flag '" + args[i] + "', please check the user guide to see the correct format. "); } string flag = ""; if (oldFlags.ContainsKey(args[i].Substring(1))) { flag = oldFlags[args[i].Substring(1)]; } else { flag = args[i].Substring(1); } // Error message if the old flag '-r' (root handling) is used if (args[i].Substring(1).Equals("r")) { throw new OptionException("The flag -r (root_handling) is replaced with two flags -nr (allow_root) and -ne (allow_reduce) since MaltParser 1.7. Read more about these changes in the user guide."); } option = optionDescriptions.getOption(flag); if (option is UnaryOption) { value = "used"; } else { i++; if (args.Length > i) { value = args[i]; } else { throw new OptionException("Could not find the corresponding value for -" + option.Flag + ". "); } } i++; } else { throw new OptionException("The option should starts with a minus sign (-), error at argument '" + args[i] + "'"); } object optionvalue = option.getValueObject(value); optionValues.addOptionValue(OptionContainer.COMMANDLINE, containerIndex, option, optionvalue); } return(true); }
/// <summary> /// Adds an option value to an option to one of the internal option container specified by the type. /// </summary> /// <param name="containerType"> the type of the option container. </param> /// <param name="containerIndex"> the index of the option container. </param> /// <param name="option"> an option to add </param> /// <param name="value"> an option value to add /// @return true if the value is added, false if the value already is in use. </param> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: protected boolean addOptionValue(int containerType, int containerIndex, org.maltparser.core.options.option.Option option, Object value) throws OptionException protected internal virtual bool addOptionValue(int containerType, int containerIndex, Option.Option option, object value) { if (option == null) { throw new OptionException("The option cannot be found. "); } if (value == null) { throw new OptionException("The option value cannot be found. "); } if (!optionContainers.ContainsKey(containerIndex)) { optionContainers[containerIndex] = new OptionContainer(containerIndex); } OptionContainer oc = optionContainers[containerIndex]; if (oc == null) { throw new OptionException("The option container index " + containerIndex + " is unknown"); } if (!oc.contains(containerType, option)) { oc.addOptionValue(containerType, option, value); return(true); } return(false); }
/// <summary> /// Parse a set of options within an option group to collect all information of individual options. /// </summary> /// <param name="group"> a reference to an individual option group in the DOM tree. </param> /// <param name="og"> a reference to the corresponding option group in the HashMap. </param> /// <exception cref="OptionException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void parseOptionsDescription(org.w3c.dom.Element group, OptionGroup og) throws org.maltparser.core.exception.MaltChainedException private void parseOptionsDescription(Element group, OptionGroup og) { NodeList options = group.getElementsByTagName("option"); Element option; for (int i = 0; i < options.Length; i++) { option = (Element)options.item(i); string optionname = option.getAttribute("name").ToLower(); string optiontype = option.getAttribute("type").ToLower(); string defaultValue = option.getAttribute("default"); string usage = option.getAttribute("usage").ToLower(); string flag = option.getAttribute("flag"); NodeList shortdescs = option.getElementsByTagName("shortdesc"); Element shortdesc; string shortdesctext = ""; if (shortdescs.Length == 1) { shortdesc = (Element)shortdescs.item(0); shortdesctext = shortdesc.TextContent; } if (optiontype.Equals("string") || optiontype.Equals("bool") || optiontype.Equals("integer") || optiontype.Equals("unary")) { Option.Option op = og.getOption(optionname); if (op != null) { throw new OptionException("The option name '" + optionname + "' for option group '" + og.Name + "' already exists. It is only allowed to override the class and enum option type to add legal value. "); } } else if (optiontype.Equals("class") || optiontype.Equals("enum") || optiontype.Equals("stringenum")) { Option.Option op = og.getOption(optionname); if (op != null) { if (op is EnumOption && !optiontype.Equals("enum")) { throw new OptionException("The option name '" + optionname + "' for option group '" + og.Name + "' already exists. The existing option is of enum type, but the new option is of '" + optiontype + "' type. "); } if (op is ClassOption && !optiontype.Equals("class")) { throw new OptionException("The option name '" + optionname + "' for option group '" + og.Name + "' already exists. The existing option is of class type, but the new option is of '" + optiontype + "' type. "); } if (op is StringEnumOption && !optiontype.Equals("stringenum")) { throw new OptionException("The option name '" + optionname + "' for option group '" + og.Name + "' already exists. The existing option is of urlenum type, but the new option is of '" + optiontype + "' type. "); } } } if (optiontype.Equals("string")) { og.addOption(new StringOption(og, optionname, shortdesctext, flag, usage, defaultValue)); } else if (optiontype.Equals("bool")) { og.addOption(new BoolOption(og, optionname, shortdesctext, flag, usage, defaultValue)); } else if (optiontype.Equals("integer")) { og.addOption(new IntegerOption(og, optionname, shortdesctext, flag, usage, defaultValue)); } else if (optiontype.Equals("unary")) { og.addOption(new UnaryOption(og, optionname, shortdesctext, flag, usage)); } else if (optiontype.Equals("enum")) { Option.Option op = og.getOption(optionname); EnumOption eop = null; if (op == null) { eop = new EnumOption(og, optionname, shortdesctext, flag, usage); } else { if (op is EnumOption) { eop = (EnumOption)op; } } NodeList legalvalues = option.getElementsByTagName("legalvalue"); Element legalvalue; for (int j = 0; j < legalvalues.Length; j++) { legalvalue = (Element)legalvalues.item(j); string legalvaluename = legalvalue.getAttribute("name"); string legalvaluetext = legalvalue.TextContent; eop.addLegalValue(legalvaluename, legalvaluetext); } if (op == null) { eop.DefaultValue = defaultValue; og.addOption(eop); } } else if (optiontype.Equals("class")) { Option.Option op = og.getOption(optionname); ClassOption cop = null; if (op == null) { cop = new ClassOption(og, optionname, shortdesctext, flag, usage); } else { if (op is ClassOption) { cop = (ClassOption)op; } } NodeList legalvalues = option.getElementsByTagName("legalvalue"); Element legalvalue; for (int j = 0; j < legalvalues.Length; j++) { legalvalue = (Element)legalvalues.item(j); string legalvaluename = legalvalue.getAttribute("name").ToLower(); string classname = legalvalue.getAttribute("class"); string legalvaluetext = legalvalue.TextContent; cop.addLegalValue(legalvaluename, legalvaluetext, classname); } if (op == null) { cop.DefaultValue = defaultValue; og.addOption(cop); } } else if (optiontype.Equals("stringenum")) { Option.Option op = og.getOption(optionname); StringEnumOption ueop = null; if (op == null) { ueop = new StringEnumOption(og, optionname, shortdesctext, flag, usage); } else { if (op is StringEnumOption) { ueop = (StringEnumOption)op; } } NodeList legalvalues = option.getElementsByTagName("legalvalue"); Element legalvalue; for (int j = 0; j < legalvalues.Length; j++) { legalvalue = (Element)legalvalues.item(j); string legalvaluename = legalvalue.getAttribute("name").ToLower(); string url = legalvalue.getAttribute("mapto"); string legalvaluetext = legalvalue.TextContent; ueop.addLegalValue(legalvaluename, legalvaluetext, url); } if (op == null) { ueop.DefaultValue = defaultValue; og.addOption(ueop); } } else { throw new OptionException("Illegal option type found in the setting file. "); } } }