parameterreader.java

非常好用的代码源代码统计分析工具的源代码

/*
 * ParameterReader.java - a class for extracting key-value pairs from
 * parameters.
 * Copyright (C) 2003-2004 Rob Spoor
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

package nl.icemanx.util;

import java.util.*;

/**
 * ParameterReader contains methods for reading and checking command line
 * parameters.
 *
 * @author  Rob Spoor
 * @version 0.4, 2003-12-01
 */
public final class ParameterReader
{
    /**
     * Indicates a key without value.
     */
    public static final int KEY = 0;

    /**
     * Indicates a key with one value, separated by whitespace.
     */
    public static final int KEY_VALUE = 1;

    /**
     * Indicates a key with one value, separated by an equals sign.
     */
    public static final int KEY_EQUALS_VALUE = 2;

    /**
     * Indicates a key with multiple values.
     */
    public static final int KEY_VALUES = 3;

    /**
     * A set of keys without values.
     */
    private Set key;

    /**
     * A set of keys with one value, separated by whitespace.
     */
    private Set keyValue;

    /**
     * A set of keys without values.
     */
    private Set keyEqualsValue;

    /**
     * A set of keys with multiple values.
     */
    private Set keyValues;

    /**
     * Creates a parameter reader. Use {@link #addKeys(Set, int)} or
     * {@link #addKey(String, int)} to set the keys.
     */
    public ParameterReader()
    {
        key = new HashSet();
        keyValue = new HashSet();
        keyEqualsValue = new HashSet();
        keyValues = new HashSet();
    }

    /**
     * Returns a set of keys.
     *
     * @param type The type of keys. See the static fields for possible
     *        values.
     * @return The set of keys of type <tt>type</tt>.
     * @throws IllegalArgumentException If the type is illegal.
     */
    public Set getKeys(int type)
    {
        switch (type)
        {
            case KEY:
                return key;
            case KEY_VALUE:
                return keyValue;
            case KEY_EQUALS_VALUE:
                return keyEqualsValue;
            case KEY_VALUES:
                return keyValues;
            default:
                throw new IllegalArgumentException("Wrong type");
        }
    }

    /**
     * Adds a set of keys.
     *
     * @param keys The set of keys.
     * @param type The type of keys. See the static fields for possible
     *        values.
     * @throws IllegalArgumentException If either the type is illegal, or
     *         there is a conflict in the keys.
     */
    public void addKeys(Set keys, int type)
    {
        checkKeys(keys);
        getKeys(type).addAll(keys);
    }

    /**
     * Adds a set of keys.
     *
     * @param keys The set of keys, in array form.
     * @param type The type of keys. See the static fields for possible
     *        values.
     * @throws IllegalArgumentException If either the type is illegal, or
     *         there is a conflict in the keys.
     */
    public void addKeys(String[] keys, int type)
    {
        addKeys(new HashSet(Arrays.asList(keys)), type);
    }

    /**
     * Adds a key.
     *
     * @param key The key.
     * @param type The type of keys. See the static fields for possible
     *        values.
     * @throws IllegalArgumentException If either the type is illegal, or
     *         there is a conflict in the keys.
     */
    public void addKey(String key, int type)
    {
        addKeys(Collections.singleton(key), type);
    }

    /**
     * Removes a set of keys.
     *
     * @param keys The set of keys.
     * @param type The type of keys. See the static fields for possible
     *        values.
     * @throws IllegalArgumentException If the type is illegal.
     */
    public void removeKeys(Set keys, int type)
    {
        getKeys(type).removeAll(keys);
    }

    /**
     * Removes a set of keys.
     *
     * @param keys The set of keys.
     * @param type The type of keys. See the static fields for possible
     *        values.
     * @throws IllegalArgumentException If the type is illegal.
     */
    public void removeKeys(String[] keys, int type)
    {
        removeKeys(new HashSet(Arrays.asList(keys)), type);
    }

    /**
     * Removes a key.
     *
     * @param key The key.
     * @param type The type of keys. See the static fields for possible
     *        values.
     * @throws IllegalArgumentException If the type is illegal.
     */
    public void removeKey(String key, int type)
    {
        removeKeys(Collections.singleton(key), type);
    }

    /**
     * Checks if any of the keys in <tt>keys</tt> is in any of the sets of
     * keys.
     *
     * @param keys The set of keys to check.
     * @throws IllegalArgumentException If any of the keys in <tt>keys</tt>
     *         is in any of the lists of keys.
     */
    private void checkKeys(Set keys)
    {
        if (!emptyIntersection(key, keys) ||
            !emptyIntersection(keyValue, keys) ||
            !emptyIntersection(keyEqualsValue, keys) ||
            !emptyIntersection(keyValues, keys))
        {
            throw new IllegalArgumentException("Duplicate key");
        }
    }

    /**
     * Checks whether two sets have an empty intersection.
     *
     * @param set1 The first set.
     * @param set2 The second set.
     * @return <tt>true</tt> iff the two sets have no common elements.
     */
    private static boolean emptyIntersection(Set set1, Set set2)
    {
        Set intersect = new HashSet(set1);
        intersect.retainAll(set2);
        return (intersect.size() == 0);
    }

    /**
     * Reads the parameters in <tt>args</tt>, and returns a map.<br>
     * The value of the key will be <tt>null</tt> if the key should have
     * no value, a string if the key should have exactly one value, and a
     * {@link List} of strings if the key can have multiple values.
     *
     * @param args An array with the parameters.
     * @return A map containing the key-value pairs of the parameters.
     * @throws IllegalArgumentException If an unknown parameter is found, or a
     *         parameter has the wrong number of values.
     * @see #addKeys(Set, int)
     * @see #addKey(String, int)
     */
    public Map readParameters(String[] args)
    {
        Map parameters = new HashMap();
        int i = 0; // for traversing args
        while (i < args.length)
        {
            if (key.contains(args[i]))
            {
                parameters.put(args[i++], null);
            }
            else if (keyValue.contains(args[i]))
            {
                if (i < args.length - 1)
                {
                    parameters.put(args[i], args[i + 1]);
                    i += 2;
                }
                else
                {
                    // i = args.length - 1, so no value left
                    throw new IllegalArgumentException(args[i]);
                }
            }
            else if (keyValues.contains(args[i]))
            {
                List list = new ArrayList();
                parameters.put(args[i++], list);
                /*
                 * Go on until either the arguments are all used up, or
                 * another key is found. In case of keyEqualsValue, split the
                 * argument in two parts at "=".
                 * args[i].split("=", 2)[0].equals(args[i]) if there is no "="
                 * in args[i].
                 */
                while ((i < args.length) &&
                       !key.contains(args[i]) &&
                       !keyValue.contains(args[i]) &&
                       !keyValues.contains(args[i]) &&
                       !keyEqualsValue.contains(args[i].split("=", 2)[0]))
                {
                    list.add(args[i++]);
                }
            }
            else
            {
                // either KEY=VALUE or unknown
                String[] split = args[i].split("=", 2);
                if (split.length == 1)
                {
                    // no "=", so unknown
                    throw new IllegalArgumentException(args[i]);
                }
                else
                {
                    if (keyEqualsValue.contains(split[0]))
                    {
                        parameters.put(split[0], split[1]);
                        i++;
                    }
                    else
                    {
                        // not known
                        throw new IllegalArgumentException(split[0]);
                    }
                }
            }
        }
        return parameters;
    }

    /**
     * Checks whether only one of the keys in <tt>keys</tt> is set in
     * <tt>parameters</tt>.
     *
     * @param parameters A map with parameters.
     * @param keys A set containing keys that should be unique in
     *        <tt>parameters</tt>.
     * @return <tt>true</tt> iff only one of the keys in <tt>keys</tt>
     *         is in <tt>parameters</tt>.
     */
    public static boolean unique(Map parameters, Set keys)
    {
        Set intersect = new HashSet(parameters.keySet());
        intersect.retainAll(keys);
        /*
         * intersect is the intersection of keys in parameters and keys in
         * keys
         */

        return (intersect.size() <= 1);
        /*
         * if the size of intersect is bigger than 1, more than 1 key in keys
         * were keys of the map.
         */
    }

    /**
     * Checks whether only one of the keys in <tt>keys</tt> is set in
     * <tt>parameters</tt>.
     *
     * @param parameters A map with parameters.
     * @param keys A list containing keys that should be unique in
     *        <tt>parameters</tt>, in array form.
     * @return <tt>true</tt> iff only one of the keys in <tt>keys</tt>
     *         is in <tt>parameters</tt>.
     */
    public static boolean unique(Map parameters, String[] keys)
    {
        return unique(parameters, new HashSet(Arrays.asList(keys)));
    }
}