001 package org.maltparser.core.options.option; 002 003 import java.util.Formatter; 004 005 import org.maltparser.core.exception.MaltChainedException; 006 import org.maltparser.core.options.OptionException; 007 import org.maltparser.core.options.OptionGroup; 008 009 /** 010 * Abstract class that contains description of an option that are the same over all option types. 011 * 012 * @author Johan Hall 013 * @since 1.0 014 **/ 015 public abstract class Option implements Comparable<Option>{ 016 public static final int NONE = 0; 017 /** 018 * The option is only relevant during learning 019 */ 020 public static final int TRAIN = 1; 021 /** 022 * The option is only relevant during processing (parsing) 023 */ 024 public static final int PROCESS = 2; 025 /** 026 * The option is relevant both during learning and processing (parsing) 027 */ 028 public static final int BOTH = 3; 029 /** 030 * The option is saved during learning and cannot be overloaded during processing (parsing) 031 */ 032 public static final int SAVE = 4; 033 034 private OptionGroup group; 035 private String name; 036 private String shortDescription; 037 private String flag; 038 private int usage; 039 private boolean ambiguous; 040 041 /** 042 * Creates an option description 043 * 044 * @param group a reference to the option group. 045 * @param name the name of the option. 046 * @param shortDescription a short description of the option. 047 * @param flag a flag that can be used in the command line. 048 * @param usage a string that explains the usage of the option. 049 * @throws OptionException 050 */ 051 public Option(OptionGroup group, String name, String shortDescription, String flag, String usage) throws MaltChainedException { 052 setGroup(group); 053 setName(name); 054 setShortDescription(shortDescription); 055 setFlag(flag); 056 setUsage(usage); 057 setAmbiguous(false); 058 } 059 060 /** 061 * Returns the corresponding object for the option value (specified as a string value). 062 * 063 * @param value the string option value 064 * @return the corresponding object for the option value (specified as a string value). 065 * @throws OptionException 066 */ 067 public abstract Object getValueObject(String value) throws MaltChainedException; 068 069 /** 070 * Returns the object for the default value for option. 071 * 072 * @return the object for the default value for option. 073 * @throws OptionException 074 */ 075 public abstract Object getDefaultValueObject() throws MaltChainedException; 076 077 /** 078 * Returns a string representation of the default value. 079 * 080 * @return a string representation of the default value 081 */ 082 public abstract String getDefaultValueString(); 083 084 /** 085 * Sets the default value for the option. 086 * 087 * @param defaultValue the string default value 088 * @throws OptionException 089 */ 090 public abstract void setDefaultValue(String defaultValue) throws MaltChainedException; 091 092 093 /** 094 * Returns a string representation of the option value. 095 * 096 * @param value an option value object 097 * @return a string representation of the option value, if the option value could not be found null is returned. 098 */ 099 public abstract String getStringRepresentation(Object value); 100 101 /** 102 * Returns a reference to a option group. 103 * 104 * @return a reference to a option group. 105 */ 106 public OptionGroup getGroup() { 107 return group; 108 } 109 /** 110 * Sets the reference to the option group 111 * @param group a reference to a option group 112 */ 113 public void setGroup(OptionGroup group) { 114 this.group = group; 115 } 116 /** 117 * Returns the name of the option. 118 * 119 * @return the name of the option. 120 */ 121 public String getName() { 122 return name; 123 } 124 /** 125 * Sets the name of the option. 126 * 127 * @param name the name of the option. 128 * @throws OptionException 129 */ 130 public void setName(String name) throws MaltChainedException { 131 if (name == null || name.length() == 0) { 132 throw new OptionException("The option name has no value. "); 133 } 134 this.name = name.toLowerCase(); 135 } 136 /** 137 * Returns a short description of the option 138 * 139 * @return a short description of the option 140 */ 141 public String getShortDescription() { 142 return shortDescription; 143 } 144 /** 145 * Sets a short description of the option 146 * 147 * @param shortDescription a short description of the option 148 */ 149 public void setShortDescription(String shortDescription) { 150 this.shortDescription = shortDescription; 151 } 152 /** 153 * Returns a character that is used as a flag for the command line input 154 * 155 * @return a character that is used as a flag for the command line input 156 */ 157 public String getFlag() { 158 return flag; 159 } 160 /** 161 * Sets a character that is used as a flag for the command line input 162 * 163 * @param flag a character that is used as a flag for the command line input 164 * @throws OptionException 165 */ 166 public void setFlag(String flag) throws MaltChainedException { 167 if (flag == null) { 168 this.flag = null; 169 } else { 170 this.flag = flag; 171 } 172 } 173 /** 174 * Returns the usage of the option. 175 * 176 * @return the usage of the option. 177 */ 178 public int getUsage() { 179 return usage; 180 } 181 /** 182 * Sets the usage of the option. 183 * 184 * @param usage the usage of the option. 185 * @throws OptionException 186 */ 187 public void setUsage(String usage) throws MaltChainedException { 188 if (usage == null || usage.equals("") || usage.toLowerCase().equals("none")) { 189 this.usage = Option.NONE; 190 } else if (usage.toLowerCase().equals("train")) { 191 this.usage = Option.TRAIN; 192 } else if (usage.toLowerCase().equals("process")) { 193 this.usage = Option.PROCESS; 194 } else if (usage.toLowerCase().equals("both")) { 195 this.usage = Option.BOTH; 196 } else if (usage.toLowerCase().equals("save")) { 197 this.usage = Option.SAVE; 198 } else { 199 throw new OptionException("Illegal use of the usage attibute value: "+usage+" for the '"+getName()+"' option. "); 200 } 201 } 202 /** 203 * Sets the usage of the option. 204 * 205 * @param usage the usage of the option. 206 * @throws OptionException 207 */ 208 public void setUsage(int usage) throws MaltChainedException { 209 if (usage >= 0 && usage <= 4) { 210 this.usage = usage; 211 } else { 212 throw new OptionException("Illegal use of the usage attibute value: "+usage+" for the '"+getName()+"' option. "); 213 } 214 } 215 216 /** 217 * Returns true if the option name is ambiguous over all option groups, otherwise false. 218 * 219 * @return true if the option name is ambiguous over all option groups, otherwise false. 220 */ 221 public boolean isAmbiguous() { 222 return ambiguous; 223 } 224 225 /** 226 * Sets true if the option name is ambiguous over all option groups, otherwise false. 227 * 228 * @param ambiguous true if the option name is ambiguous over all option groups, otherwise false. 229 */ 230 public void setAmbiguous(boolean ambiguous) { 231 this.ambiguous = ambiguous; 232 } 233 234 public int compareTo(Option o) { 235 if (group.getName().equals(o.group.getName())) { 236 return name.compareTo(o.getName()); 237 } 238 return group.getName().compareTo(o.group.getName()); 239 } 240 241 /* (non-Javadoc) 242 * @see java.lang.Object#toString() 243 */ 244 public String toString() { 245 int splitsize = 45; 246 final StringBuilder sb = new StringBuilder(); 247 Formatter formatter = new Formatter(sb); 248 formatter.format("%-20s ", getName()); 249 if (isAmbiguous()) { 250 formatter.format("*"); 251 } else { 252 sb.append(" "); 253 } 254 if (getFlag() != null) { 255 formatter.format("(%4s) : ", "-"+getFlag()); 256 } else { 257 sb.append(" : "); 258 } 259 int r = shortDescription.length() / splitsize; 260 for (int i = 0; i <= r; i++) { 261 if (shortDescription.substring(splitsize*i).length() <= splitsize) { 262 formatter.format(((i==0)?"%s":"%28s")+"%-45s\n", "", shortDescription.substring(splitsize*i)); 263 } else { 264 formatter.format(((i==0)?"%s":"%28s")+"%-45s\n", "", shortDescription.substring(splitsize*i, splitsize*i+splitsize)); 265 } 266 } 267 return sb.toString(); 268 } 269 }