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    }