    001    package org.maltparser.core.options;
    002
    003    import java.util.SortedMap;
    004    import java.util.SortedSet;
    005    import java.util.TreeMap;
    006    import java.util.TreeSet;
    007
    008    import org.maltparser.core.options.option.Option;
    009
    010    /**
    011     * An option container stores the option values for one instance usage. For example, a
    012     * single malt configuration there will only be one option container, but for an ensemble parser there
    013     * could be several option containers.
    014     *
    015     * There are four types internal option container:
    016     * <ul>
    017     * <li>SAVEDOPTION, contains option values load from the saved option file.
    018     * <li>DEPENDENCIES_RESOLVED, contains option values that overload option values in COMMANDLINE and OPTIONFILE
    019     * due to dependencies with other options.
    020     * <li>COMMANDLINE, contains option values that are read from the command-line prompt.
    021     * <li>OPTIONFILE, contains option values that are read from the option file.
    022     * </ul>
    023     * <p>These internal option containers have following priority: SAVEDOPTION, DEPENDENCIES_RESOLVED, COMMANDLINE,
    024     * OPTIONFILE. If an option cannot be found in the SAVEDOPTION internal option container it will continue to
    025     * look in the DEPENDENCIES_RESOLVED internal option container and and so fourth. If the option value cannot be
    026     * found in none of the internal option container, the option manager uses the default option value provided by
    027     * the option description.</p>
    028     *
    029     * @author Johan Hall
    030     * @since 1.0
    031    **/
    032    public class OptionContainer implements Comparable<OptionContainer>{
    033            /* Types of internal option container */
    034            public static final int SAVEDOPTION = 0;
    035            public static final int DEPENDENCIES_RESOLVED = 1;
    036            public static final int COMMANDLINE = 2;
    037            public static final int OPTIONFILE = 3;
    038
    039            private int index;
    040            private SortedMap<Option,Object> savedOptionMap;
    041            private SortedMap<Option,Object> dependenciesResolvedOptionMap;
    042            private SortedMap<Option,Object> commandLineOptionMap;
    043            private SortedMap<Option,Object> optionFileOptionMap;
    044
    045            /**
    046             * Creates an option container
    047             *
    048             * @param index The index of the option container (0..n).
    049             */
    050            public OptionContainer(int index) throws OptionException {
    051                    setIndex(index);
    052                    savedOptionMap = new TreeMap<Option,Object>();
    053                    dependenciesResolvedOptionMap = new TreeMap<Option,Object>();
    054                    commandLineOptionMap = new TreeMap<Option,Object>();
    055                    optionFileOptionMap = new TreeMap<Option,Object>();
    056            }
    057
    058            /**
    059             * Adds an option value to an option to one of the internal option container specified by the type.
    060             *
    061             * @param type  the internal option container
    062             * @param option        the option object
    063             * @param value         the option value object
    064             * @throws OptionException
    065             */
    066            public void addOptionValue(int type, Option option, Object value) throws OptionException {
    067                    if (type == OptionContainer.SAVEDOPTION) {
    068                            savedOptionMap.put(option, value);
    069                    } else if (type == OptionContainer.DEPENDENCIES_RESOLVED) {
    070                            dependenciesResolvedOptionMap.put(option, value);
    071                    } else if (type == OptionContainer.COMMANDLINE) {
    072                            commandLineOptionMap.put(option, value);
    073                    } else if (type == OptionContainer.OPTIONFILE) {
    074                            optionFileOptionMap.put(option, value);
    075                    } else {
    076                            throw new OptionException("Unknown option container type");
    077                    }
    078            }
    079
    080            /**
    081             * Returns the option value object for the option. It uses the priority amongst the internal
    082             * option containers.
    083             *
    084             * @param option the option object
    085             * @return the option value object
    086             */
    087            public Object getOptionValue(Option option) {
    088                    Object value = null;
    089                    for (int i = OptionContainer.SAVEDOPTION; i <= OptionContainer.OPTIONFILE; i++) {
    090                            if (i == OptionContainer.SAVEDOPTION) {
    091                                    value = savedOptionMap.get(option);
    092                            } else if (i == OptionContainer.DEPENDENCIES_RESOLVED) {
    093                                    value = dependenciesResolvedOptionMap.get(option);
    094                            } else if (i == OptionContainer.COMMANDLINE) {
    095                                    value = commandLineOptionMap.get(option);
    096                            } else if (i == OptionContainer.OPTIONFILE) {
    097                                    value = optionFileOptionMap.get(option);
    098                            }
    099                            if (value != null) {
    100                                    return value;
    101                            }
    102                    }
    103                    return null;
    104            }
    105
    106            /**
    107             * Returns a string representation of the option value for the specified option. It uses the priority
    108             * amongst the internal option containers.
    109             *
    110             * @param option the option object
    111             * @return a string representation of the option value
    112             */
    113            public String getOptionValueString(Option option) {
    114                    String value = null;
    115                    for (int i = OptionContainer.SAVEDOPTION; i <= OptionContainer.OPTIONFILE; i++) {
    116                            if (i == OptionContainer.SAVEDOPTION) {
    117                                    value = option.getStringRepresentation(savedOptionMap.get(option));
    118                            } else if (i == OptionContainer.DEPENDENCIES_RESOLVED) {
    119                                    value = option.getStringRepresentation(dependenciesResolvedOptionMap.get(option));
    120                            } else if (i == OptionContainer.COMMANDLINE) {
    121                                    value = option.getStringRepresentation(commandLineOptionMap.get(option));
    122                            } else if (i == OptionContainer.OPTIONFILE) {
    123                                    value = option.getStringRepresentation(optionFileOptionMap.get(option));
    124                            }
    125                            if (value != null) {
    126                                    return value;
    127                            }
    128                    }
    129                    return null;
    130            }
    131
    132
    133            /**
    134             * Returns true if the option is present in the specified internal option container, otherwise false.
    135             *
    136             * @param type  the internal option container
    137             * @param option        the option object
    138             * @return true if the option is present in the specified internal option container, otherwise false
    139             * @throws OptionException
    140             */
    141            public boolean contains(int type, Option option) throws OptionException {
    142                    if (type == OptionContainer.SAVEDOPTION) {
    143                            return savedOptionMap.containsValue(option);
    144                    } else if (type == OptionContainer.DEPENDENCIES_RESOLVED) {
    145                            return dependenciesResolvedOptionMap.containsValue(option);
    146                    } else if (type == OptionContainer.COMMANDLINE) {
    147                            return commandLineOptionMap.containsValue(option);
    148                    } else if (type == OptionContainer.OPTIONFILE) {
    149                            return optionFileOptionMap.containsValue(option);
    150                    } else {
    151                            throw new OptionException("Unknown option container type");
    152                    }
    153            }
    154
    155            /**
    156             * Returns the number of option values amongst all internal option containers.
    157             *
    158             * @return the number of option values amongst all internal option containers
    159             */
    160            public int getNumberOfOptionValues() {
    161                    SortedSet<Option> union = new TreeSet<Option>(savedOptionMap.keySet());
    162                    union.addAll(dependenciesResolvedOptionMap.keySet());
    163                    union.addAll(commandLineOptionMap.keySet());
    164                    union.addAll(optionFileOptionMap.keySet());
    165                    return union.size();
    166            }
    167
    168            /**
    169             * Returns the option container index.
    170             *
    171             * @return the option container index
    172             */
    173            public int getIndex() {
    174                    return index;
    175            }
    176
    177            /**
    178             * Sets the option container index, if the index is great than or equal 0.
    179             * @param index the option container index
    180             * @throws OptionException
    181             */
    182            private void setIndex(int index) throws OptionException {
    183                    if (index < 0) {
    184                            throw new OptionException("The option container index must be an integer value great than or equal 0. ");
    185                    }
    186                    this.index = index;
    187            }
    188
    189            public int compareTo(OptionContainer that) {
    190                    final int BEFORE = -1;
    191                final int EQUAL = 0;
    192                final int AFTER = 1;
    193                if (this == that) return EQUAL;
    194                if (this.index < that.index) return BEFORE;
    195                if (this.index > that.index) return AFTER;
    196                return EQUAL;
    197            }
    198
    199
    200            /* (non-Javadoc)
    201             * @see java.lang.Object#toString()
    202             */
    203            public String toString() {
    204                    final StringBuilder sb = new StringBuilder();
    205                    SortedSet<Option> union = new TreeSet<Option>(savedOptionMap.keySet());
    206                    union.addAll(dependenciesResolvedOptionMap.keySet());
    207                    union.addAll(commandLineOptionMap.keySet());
    208                    union.addAll(optionFileOptionMap.keySet());
    209                    for (Option option : union) {
    210                            Object value = null;
    211                            for (int i = OptionContainer.SAVEDOPTION; i <= OptionContainer.OPTIONFILE; i++) {
    212                                    if (i == OptionContainer.SAVEDOPTION) {
    213                                            value = savedOptionMap.get(option);
    214                                    } else if (i == OptionContainer.DEPENDENCIES_RESOLVED) {
    215                                            value = dependenciesResolvedOptionMap.get(option);
    216                                    } else if (i == OptionContainer.COMMANDLINE) {
    217                                            value = commandLineOptionMap.get(option);
    218                                    } else if (i == OptionContainer.OPTIONFILE) {
    219                                            value = optionFileOptionMap.get(option);
    220                                    }
    221                                    if (value != null) {
    222                                            break;
    223                                    }
    224                            }
    225                            sb.append(option.getGroup().getName()+"\t"+option.getName()+"\t"+value+"\n");
    226                    }
    227                    return sb.toString();
    228            }
    229
    230    }