Java example source code file (OptionTemplate.java)

This example Java source code file (OptionTemplate.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

comparable, illegalargumentexception, line_break, object, optiontemplate, override, quotedstringtokenizer, string, stringbuilder, util

The OptionTemplate.java Java example source code

/*
 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package jdk.nashorn.internal.runtime.options;

import java.util.Locale;
import java.util.TimeZone;
import jdk.nashorn.internal.runtime.QuotedStringTokenizer;

/**
 * This describes the valid input for an option, as read from the resource
 * bundle file. Metainfo such as parameters and description is here as well
 * for context sensitive help generation.
 */
public final class OptionTemplate implements Comparable<OptionTemplate> {
    /** Resource, e.g. "nashorn" for this option */
    private final String resource;

    /** Key in the resource bundle */
    private final String key;

    /** Is this option a help option? */
    private final boolean isHelp;

    /** Is this option a extended help option? */
    private final boolean isXHelp;

    /** Name - for example --dump-on-error (usually prefixed with --) */
    private String name;

    /** Short name - for example -doe (usually prefixed with -) */
    private String shortName;

    /** Params - a parameter template string */
    private String params;

    /** Type - e.g. "boolean". */
    private String type;

    /** Does this option have a default value? */
    private String defaultValue;

    /** Does this option activate another option when set? */
    private String dependency;

    /** Does this option conflict with another? */
    private String conflict;

    /** Is this a documented option that should show up in help? */
    private boolean isUndocumented;

    /** A longer description of what this option does */
    private String description;

    /** is the option value specified as next argument? */
    private boolean valueNextArg;

    OptionTemplate(final String resource, final String key, final String value, final boolean isHelp, final boolean isXHelp) {
        this.resource = resource;
        this.key = key;
        this.isHelp = isHelp;
        this.isXHelp = isXHelp;
        parse(value);
    }

    /**
     * Is this the special help option, used to generate help for
     * all the others
     *
     * @return true if this is the help option
     */
    public boolean isHelp() {
        return this.isHelp;
    }

    /**
     * Is this the special extended help option, used to generate extended help for
     * all the others
     *
     * @return true if this is the extended help option
     */
    public boolean isXHelp() {
        return this.isXHelp;
    }

    /**
     * Get the resource name used to prefix this option set, e.g. "nashorn"
     *
     * @return the name of the resource
     */
    public String getResource() {
        return this.resource;
    }

    /**
     * Get the type of this option
     *
     * @return the type of the option
     */
    public String getType() {
        return this.type;
    }

    /**
     * Get the key of this option
     *
     * @return the key
     */
    public String getKey() {
        return this.key;
    }

    /**
     * Get the default value for this option
     *
     * @return the default value as a string
     */
    public String getDefaultValue() {
        switch (getType()) {
        case "boolean":
            if (this.defaultValue == null) {
                this.defaultValue = "false";
            }
            break;
        case "integer":
            if (this.defaultValue == null) {
                this.defaultValue = "0";
            }
            break;
        case "timezone":
            this.defaultValue = TimeZone.getDefault().getID();
            break;
        case "locale":
            this.defaultValue = Locale.getDefault().toLanguageTag();
            break;
        default:
            break;
        }
        return this.defaultValue;
    }

    /**
     * Does this option automatically enable another option, i.e. a dependency.
     * @return the dependecy or null if non exists
     */
    public String getDependency() {
        return this.dependency;
    }

    /**
     * Is this option in conflict with another option so that both can't be enabled
     * at the same time
     *
     * @return the conflicting option or null if none exists
     */
    public String getConflict() {
        return this.conflict;
    }

    /**
     * Is this option undocumented, i.e. should not show up in the standard help output
     *
     * @return true if option is undocumented
     */
    public boolean isUndocumented() {
        return this.isUndocumented;
    }

    /**
     * Get the short version of this option name if one exists, e.g. "-co" for "--compile-only"
     *
     * @return the short name
     */
    public String getShortName() {
        return this.shortName;
    }

    /**
     * Get the name of this option, e.g. "--compile-only". A name always exists
     *
     * @return the name of the option
     */
    public String getName() {
        return this.name;
    }

    /**
     * Get the description of this option.
     *
     * @return the description
     */
    public String getDescription() {
        return this.description;
    }

    /**
     * Is value of this option passed as next argument?
     * @return boolean
     */
    public boolean isValueNextArg() {
        return valueNextArg;
    }

    private static String strip(final String value, final char start, final char end) {
        final int len = value.length();
        if (len > 1 && value.charAt(0) == start && value.charAt(len - 1) == end) {
            return value.substring(1, len - 1);
        }
        return null;
    }

    private void parse(final String origValue) {
        String value = origValue.trim();

        try {
            value = OptionTemplate.strip(value, '{', '}');
            final QuotedStringTokenizer keyValuePairs = new QuotedStringTokenizer(value, ",");

            while (keyValuePairs.hasMoreTokens()) {
                final String                keyValue = keyValuePairs.nextToken();
                final QuotedStringTokenizer st       = new QuotedStringTokenizer(keyValue, "=");
                final String                keyToken = st.nextToken();
                final String                arg      = st.nextToken();

                switch (keyToken) {
                case "is_undocumented":
                    this.isUndocumented = Boolean.parseBoolean(arg);
                    break;
                case "name":
                    if (!arg.startsWith("-")) {
                        throw new IllegalArgumentException(arg);
                    }
                    this.name = arg;
                    break;
                case "short_name":
                    if (!arg.startsWith("-")) {
                        throw new IllegalArgumentException(arg);
                    }
                    this.shortName = arg;
                    break;
                case "desc":
                    this.description = arg;
                    break;
                case "params":
                    this.params = arg;
                    break;
                case "type":
                    this.type = arg.toLowerCase(Locale.ENGLISH);
                    break;
                case "default":
                    this.defaultValue = arg;
                    break;
                case "dependency":
                    this.dependency = arg;
                    break;
                case "conflict":
                    this.conflict = arg;
                    break;
                case "value_next_arg":
                    this.valueNextArg = Boolean.parseBoolean(arg);
                    break;
                default:
                    throw new IllegalArgumentException(keyToken);
                }
            }

            // default to boolean if no type is given
            if (this.type == null) {
                this.type = "boolean";
            }

            if (this.params == null && "boolean".equals(this.type)) {
                this.params = "[true|false]";
            }

        } catch (final Exception e) {
            throw new IllegalArgumentException(origValue);
        }

        if (name == null && shortName == null) {
            throw new IllegalArgumentException(origValue);
        }
    }

    boolean matches(final String key0) {
        return key0.equals(this.shortName) || key0.equals(this.name);
    }

    private static final int LINE_BREAK = 64;

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();

        sb.append('\t');

        if (shortName != null) {
            sb.append(shortName);
            if (name != null) {
                sb.append(", ");
            }
        }

        if (name != null) {
            sb.append(name);
        }

        if (description != null) {
            final int indent = sb.length();
            sb.append(' ');
            sb.append('(');
            int pos = 0;
            for (final char c : description.toCharArray()) {
                sb.append(c);
                pos++;
                if (pos >= LINE_BREAK && Character.isWhitespace(c)) {
                    pos = 0;
                    sb.append("\n\t");
                    for (int i = 0; i < indent; i++) {
                        sb.append(' ');
                    }
                }
            }
            sb.append(')');
        }

        if (params != null) {
            sb.append('\n');
            sb.append('\t');
            sb.append('\t');
            sb.append(Options.getMsg("nashorn.options.param")).append(": ");
            sb.append(params);
            sb.append("   ");
            final Object def = this.getDefaultValue();
            if (def != null) {
                sb.append(Options.getMsg("nashorn.options.default")).append(": ");
                sb.append(this.getDefaultValue());
            }
        }


        return sb.toString();
    }

    @Override
    public int compareTo(final OptionTemplate o) {
        return this.getKey().compareTo(o.getKey());
    }
}