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    }