Java example source code file (MimeTypeParameterList.java)

This example Java source code file (MimeTypeParameterList.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

couldn\'t, encountered, enumeration, hashtable, mimetypeparameterlist, mimetypeparseexception, more, string, stringbuffer, tspecials, unexpected, util

The MimeTypeParameterList.java Java example source code

/*
 * Copyright (c) 1997, 2005, 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 javax.activation;

import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Locale;

/**
 * A parameter list of a MimeType
 * as defined in RFC 2045 and 2046. The Primary type of the
 * object must already be stripped off.
 *
 * @see javax.activation.MimeType
 *
 * @since 1.6
 */
public class MimeTypeParameterList {
    private Hashtable parameters;

    /**
     * A string that holds all the special chars.
     */
    private static final String TSPECIALS = "()<>@,;:/[]?=\\\"";


    /**
     * Default constructor.
     */
    public MimeTypeParameterList() {
        parameters = new Hashtable();
    }

    /**
     * Constructs a new MimeTypeParameterList with the passed in data.
     *
     * @param parameterList an RFC 2045, 2046 compliant parameter list.
     */
    public MimeTypeParameterList(String parameterList)
                                        throws MimeTypeParseException {
        parameters = new Hashtable();

        //    now parse rawdata
        parse(parameterList);
    }

    /**
     * A routine for parsing the parameter list out of a String.
     *
     * @param parameterList an RFC 2045, 2046 compliant parameter list.
     */
    protected void parse(String parameterList) throws MimeTypeParseException {
        if (parameterList == null)
            return;

        int length = parameterList.length();
        if (length <= 0)
            return;

        int i;
        char c;
        for (i = skipWhiteSpace(parameterList, 0);
                i < length && (c = parameterList.charAt(i)) == ';';
                i = skipWhiteSpace(parameterList, i)) {
            int lastIndex;
            String name;
            String value;

            //    eat the ';'
            i++;

            //    now parse the parameter name

            //    skip whitespace
            i = skipWhiteSpace(parameterList, i);

            // tolerate trailing semicolon, even though it violates the spec
            if (i >= length)
                return;

            //    find the end of the token char run
            lastIndex = i;
            while ((i < length) && isTokenChar(parameterList.charAt(i)))
                i++;

            name = parameterList.substring(lastIndex, i).
                                                toLowerCase(Locale.ENGLISH);

            //    now parse the '=' that separates the name from the value
            i = skipWhiteSpace(parameterList, i);

            if (i >= length || parameterList.charAt(i) != '=')
                throw new MimeTypeParseException(
                    "Couldn't find the '=' that separates a " +
                    "parameter name from its value.");

            //    eat it and parse the parameter value
            i++;
            i = skipWhiteSpace(parameterList, i);

            if (i >= length)
                throw new MimeTypeParseException(
                        "Couldn't find a value for parameter named " + name);

            //    now find out whether or not we have a quoted value
            c = parameterList.charAt(i);
            if (c == '"') {
                //    yup it's quoted so eat it and capture the quoted string
                i++;
                if (i >= length)
                    throw new MimeTypeParseException(
                            "Encountered unterminated quoted parameter value.");

                lastIndex = i;

                //    find the next unescaped quote
                while (i < length) {
                    c = parameterList.charAt(i);
                    if (c == '"')
                        break;
                    if (c == '\\') {
                        //    found an escape sequence
                        //    so skip this and the
                        //    next character
                        i++;
                    }
                    i++;
                }
                if (c != '"')
                    throw new MimeTypeParseException(
                        "Encountered unterminated quoted parameter value.");

                value = unquote(parameterList.substring(lastIndex, i));
                //    eat the quote
                i++;
            } else if (isTokenChar(c)) {
                //    nope it's an ordinary token so it
                //    ends with a non-token char
                lastIndex = i;
                while (i < length && isTokenChar(parameterList.charAt(i)))
                    i++;
                value = parameterList.substring(lastIndex, i);
            } else {
                //    it ain't a value
                throw new MimeTypeParseException(
                        "Unexpected character encountered at index " + i);
            }

            //    now put the data into the hashtable
            parameters.put(name, value);
        }
        if (i < length) {
            throw new MimeTypeParseException(
                "More characters encountered in input than expected.");
        }
    }

    /**
     * Return the number of name-value pairs in this list.
     *
     * @return  the number of parameters
     */
    public int size() {
        return parameters.size();
    }

    /**
     * Determine whether or not this list is empty.
     *
     * @return  true if there are no parameters
     */
    public boolean isEmpty() {
        return parameters.isEmpty();
    }

    /**
     * Retrieve the value associated with the given name, or null if there
     * is no current association.
     *
     * @param name      the parameter name
     * @return          the parameter's value
     */
    public String get(String name) {
        return (String)parameters.get(name.trim().toLowerCase(Locale.ENGLISH));
    }

    /**
     * Set the value to be associated with the given name, replacing
     * any previous association.
     *
     * @param name      the parameter name
     * @param value     the parameter's value
     */
    public void set(String name, String value) {
        parameters.put(name.trim().toLowerCase(Locale.ENGLISH), value);
    }

    /**
     * Remove any value associated with the given name.
     *
     * @param name      the parameter name
     */
    public void remove(String name) {
        parameters.remove(name.trim().toLowerCase(Locale.ENGLISH));
    }

    /**
     * Retrieve an enumeration of all the names in this list.
     *
     * @return  an enumeration of all parameter names
     */
    public Enumeration getNames() {
        return parameters.keys();
    }

    /**
     * Return a string representation of this object.
     */
    public String toString() {
        StringBuffer buffer = new StringBuffer();
        buffer.ensureCapacity(parameters.size() * 16);
                        //    heuristic: 8 characters per field

        Enumeration keys = parameters.keys();
        while (keys.hasMoreElements()) {
            String key = (String)keys.nextElement();
            buffer.append("; ");
            buffer.append(key);
            buffer.append('=');
            buffer.append(quote((String)parameters.get(key)));
        }

        return buffer.toString();
    }

    //    below here be scary parsing related things

    /**
     * Determine whether or not a given character belongs to a legal token.
     */
    private static boolean isTokenChar(char c) {
        return ((c > 040) && (c < 0177)) && (TSPECIALS.indexOf(c) < 0);
    }

    /**
     * return the index of the first non white space character in
     * rawdata at or after index i.
     */
    private static int skipWhiteSpace(String rawdata, int i) {
        int length = rawdata.length();
        while ((i < length) && Character.isWhitespace(rawdata.charAt(i)))
            i++;
        return i;
    }

    /**
     * A routine that knows how and when to quote and escape the given value.
     */
    private static String quote(String value) {
        boolean needsQuotes = false;

        //    check to see if we actually have to quote this thing
        int length = value.length();
        for (int i = 0; (i < length) && !needsQuotes; i++) {
            needsQuotes = !isTokenChar(value.charAt(i));
        }

        if (needsQuotes) {
            StringBuffer buffer = new StringBuffer();
            buffer.ensureCapacity((int)(length * 1.5));

            //    add the initial quote
            buffer.append('"');

            //    add the properly escaped text
            for (int i = 0; i < length; ++i) {
                char c = value.charAt(i);
                if ((c == '\\') || (c == '"'))
                    buffer.append('\\');
                buffer.append(c);
            }

            //    add the closing quote
            buffer.append('"');

            return buffer.toString();
        } else {
            return value;
        }
    }

    /**
     * A routine that knows how to strip the quotes and
     * escape sequences from the given value.
     */
    private static String unquote(String value) {
        int valueLength = value.length();
        StringBuffer buffer = new StringBuffer();
        buffer.ensureCapacity(valueLength);

        boolean escaped = false;
        for (int i = 0; i < valueLength; ++i) {
            char currentChar = value.charAt(i);
            if (!escaped && (currentChar != '\\')) {
                buffer.append(currentChar);
            } else if (escaped) {
                buffer.append(currentChar);
                escaped = false;
            } else {
                escaped = true;
            }
        }

        return buffer.toString();
    }
}