001 package org.maltparser.core.options.option; 002 003 import java.util.Formatter; 004 import java.util.HashMap; 005 import java.util.TreeSet; 006 007 import org.maltparser.core.exception.MaltChainedException; 008 import org.maltparser.core.options.OptionException; 009 import org.maltparser.core.options.OptionGroup; 010 011 /** 012 * A string enum type option is an option that can only contain string value that corresponds to another string. 013 * 014 * @author Johan Hall 015 * @since 1.0 016 **/ 017 public class StringEnumOption extends Option{ 018 private String defaultValue; 019 private TreeSet<String> legalValues; 020 private HashMap<String,String> legalValueDesc; 021 private HashMap<String,String> valueMapto; 022 private HashMap<String, String> maptoValue; 023 024 /** 025 * Creates a stringenum type option description 026 * 027 * @param group a reference to the option group. 028 * @param name the name of the option. 029 * @param shortDescription a short description of the option. 030 * @param flag a short string that can be used in the command line. 031 * @param usage a string that explains the usage of the option. 032 * @throws OptionException 033 */ 034 public StringEnumOption(OptionGroup group, 035 String name, 036 String shortDescription, 037 String flag, 038 String usage) throws MaltChainedException { 039 super(group, name, shortDescription, flag, usage); 040 legalValues = new TreeSet<String>(); 041 legalValueDesc = new HashMap<String,String>(); 042 valueMapto = new HashMap<String,String>(); 043 maptoValue = new HashMap<String, String>(); 044 } 045 046 /* (non-Javadoc) 047 * @see org.maltparser.core.options.option.Option#getValueObject(java.lang.String) 048 */ 049 public Object getValueObject(String value) throws MaltChainedException { 050 if (value == null) { 051 return null; 052 } else if (legalValues.contains(value)) { 053 return new String(valueMapto.get(value)); 054 } else { 055 return new String(value); 056 } 057 } 058 059 /* (non-Javadoc) 060 * @see org.maltparser.core.options.option.Option#getDefaultValueObject() 061 */ 062 public Object getDefaultValueObject() throws MaltChainedException { 063 return new String(defaultValue); 064 } 065 066 /** 067 * Returns the legal value identifier name (an enumerate string value) 068 * 069 * @param value the mapped legal value 070 * @return the legal value identifier name, null if it could not be found 071 * @throws MaltChainedException 072 */ 073 public String getLegalValueString(String value) throws MaltChainedException { 074 return new String(maptoValue.get(value)); 075 } 076 077 /** 078 * Returns the mapped legal value 079 * 080 * @param value an enumerate string value 081 * @return the mapped legal value, null if it could not be found 082 * @throws MaltChainedException 083 */ 084 public String getLegalValueMapToString(String value) throws MaltChainedException { 085 return new String(valueMapto.get(value)); 086 } 087 088 /* (non-Javadoc) 089 * @see org.maltparser.core.options.option.Option#setDefaultValue(java.lang.String) 090 */ 091 public void setDefaultValue(String defaultValue) throws MaltChainedException { 092 if (defaultValue == null) { 093 if (legalValues.isEmpty()) { 094 throw new OptionException("The default value is null and the legal value set is empty for the '"+getName()+"' option. "); 095 } else { 096 this.defaultValue = valueMapto.get(((TreeSet<String>)valueMapto.keySet()).first()); 097 } 098 } else if (legalValues.contains(defaultValue.toLowerCase())) { 099 this.defaultValue = valueMapto.get(defaultValue.toLowerCase()); 100 } else if (defaultValue.equals("")) { 101 this.defaultValue = defaultValue; 102 } else { 103 throw new OptionException("The default value '"+defaultValue+"' for the '"+getName()+"' option is not a legal value. "); 104 } 105 } 106 107 /* (non-Javadoc) 108 * @see org.maltparser.core.options.option.Option#getDefaultValueString() 109 */ 110 public String getDefaultValueString() { 111 return defaultValue.toString(); 112 } 113 114 /** 115 * Returns the mapped legal value that corresponds to the enumerate string value. 116 * 117 * @param value an enumerate string value 118 * @return the mapped legal value that corresponds to the enumerate string value. 119 */ 120 public String getMapto(String value) { 121 return new String(valueMapto.get(value)); 122 } 123 124 /** 125 * Adds a legal value that corresponds to another string 126 * 127 * @param value a legal value name 128 * @param desc a short description of the legal value 129 * @param mapto a mapto string value 130 * @throws OptionException 131 */ 132 public void addLegalValue(String value, String desc, String mapto) throws MaltChainedException { 133 if (value == null || value.equals("")) { 134 throw new OptionException("The legal value is missing for the option "+getName()+"."); 135 } else if (legalValues.contains(value.toLowerCase())) { 136 throw new OptionException("The legal value "+value+" already exists for the option "+getName()+". "); 137 } else { 138 legalValues.add(value.toLowerCase()); 139 if (desc == null || desc.equals("")) { 140 legalValueDesc.put(value.toLowerCase(), "Description is missing. "); 141 } else { 142 legalValueDesc.put(value.toLowerCase(), desc); 143 } 144 if (mapto == null || mapto.equals("")) { 145 throw new OptionException("A mapto value is missing for the option "+getName()+". "); 146 } else { 147 valueMapto.put(value, mapto); 148 maptoValue.put(mapto, value); 149 } 150 } 151 } 152 153 /* (non-Javadoc) 154 * @see org.maltparser.core.options.option.Option#getStringRepresentation(java.lang.Object) 155 */ 156 public String getStringRepresentation(Object value) { 157 if (value instanceof String) { 158 if (legalValues.contains(value)) { 159 return valueMapto.get(value); 160 } else { 161 return value.toString(); 162 } 163 } 164 return null; 165 } 166 167 /* (non-Javadoc) 168 * @see org.maltparser.core.options.option.Option#toString() 169 */ 170 public String toString() { 171 final StringBuilder sb = new StringBuilder(); 172 sb.append(super.toString()); 173 Formatter formatter = new Formatter(sb); 174 for (String value : legalValues) { 175 formatter.format("%2s%-10s - %-20s\n", "", value, legalValueDesc.get(value)); 176 } 177 return sb.toString(); 178 } 179 }