Java tutorial
/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * * Copyright (c) 1997-2017 Oracle and/or its affiliates. All rights reserved. * * The contents of this file are subject to the terms of either the GNU * General Public License Version 2 only ("GPL") or the Common Development * and Distribution License("CDDL") (collectively, the "License"). You * may not use this file except in compliance with the License. You can * obtain a copy of the License at * https://oss.oracle.com/licenses/CDDL+GPL-1.1 * or LICENSE.txt. See the License for the specific * language governing permissions and limitations under the License. * * When distributing the software, include this License Header Notice in each * file and include the License file at LICENSE.txt. * * GPL Classpath Exception: * Oracle designates this particular file as subject to the "Classpath" * exception as provided by Oracle in the GPL Version 2 section of the License * file that accompanied this code. * * Modifications: * If applicable, add the following below the License Header, with the fields * enclosed by brackets [] replaced by your own identifying information: * "Portions Copyright [year] [name of copyright owner]" * * Contributor(s): * If you wish your version of this file to be governed by only the CDDL or * only the GPL Version 2, indicate your decision by adding "[Contributor] * elects to include this software in this distribution under the [CDDL or GPL * Version 2] license." If you don't indicate a single choice of license, a * recipient has the option to distribute your version of this file under * either the CDDL, the GPL Version 2 or to extend the choice of license to * its licensees as provided above. However, if you add GPL Version 2 code * and therefore, elected the GPL Version 2 license, then the option applies * only if the new code is made subject to such option by the copyright * holder. */ package javax.activation; import java.io.*; import java.util.Locale; /** * A Multipurpose Internet Mail Extension (MIME) type, as defined * in RFC 2045 and 2046. */ public class MimeType implements Externalizable { private String primaryType; private String subType; private MimeTypeParameterList parameters; /** * A string that holds all the special chars. */ private static final String TSPECIALS = "()<>@,;:/[]?=\\\""; /** * Default constructor. */ public MimeType() { primaryType = "application"; subType = "*"; parameters = new MimeTypeParameterList(); } /** * Constructor that builds a MimeType from a String. * * @param rawdata the MIME type string * @exception MimeTypeParseException if the MIME type can't be parsed */ public MimeType(String rawdata) throws MimeTypeParseException { parse(rawdata); } /** * Constructor that builds a MimeType with the given primary and sub type * but has an empty parameter list. * * @param primary the primary MIME type * @param sub the MIME sub-type * @exception MimeTypeParseException if the primary type or subtype * is not a valid token */ public MimeType(String primary, String sub) throws MimeTypeParseException { // check to see if primary is valid if (isValidToken(primary)) { primaryType = primary.toLowerCase(Locale.ENGLISH); } else { throw new MimeTypeParseException("Primary type is invalid."); } // check to see if sub is valid if (isValidToken(sub)) { subType = sub.toLowerCase(Locale.ENGLISH); } else { throw new MimeTypeParseException("Sub type is invalid."); } parameters = new MimeTypeParameterList(); } /** * A routine for parsing the MIME type out of a String. */ private void parse(String rawdata) throws MimeTypeParseException { int slashIndex = rawdata.indexOf('/'); int semIndex = rawdata.indexOf(';'); if ((slashIndex < 0) && (semIndex < 0)) { // neither character is present, so treat it // as an error throw new MimeTypeParseException("Unable to find a sub type."); } else if ((slashIndex < 0) && (semIndex >= 0)) { // we have a ';' (and therefore a parameter list), // but no '/' indicating a sub type is present throw new MimeTypeParseException("Unable to find a sub type."); } else if ((slashIndex >= 0) && (semIndex < 0)) { // we have a primary and sub type but no parameter list primaryType = rawdata.substring(0, slashIndex).trim().toLowerCase(Locale.ENGLISH); subType = rawdata.substring(slashIndex + 1).trim().toLowerCase(Locale.ENGLISH); parameters = new MimeTypeParameterList(); } else if (slashIndex < semIndex) { // we have all three items in the proper sequence primaryType = rawdata.substring(0, slashIndex).trim().toLowerCase(Locale.ENGLISH); subType = rawdata.substring(slashIndex + 1, semIndex).trim().toLowerCase(Locale.ENGLISH); parameters = new MimeTypeParameterList(rawdata.substring(semIndex)); } else { // we have a ';' lexically before a '/' which means we // have a primary type and a parameter list but no sub type throw new MimeTypeParseException("Unable to find a sub type."); } // now validate the primary and sub types // check to see if primary is valid if (!isValidToken(primaryType)) throw new MimeTypeParseException("Primary type is invalid."); // check to see if sub is valid if (!isValidToken(subType)) throw new MimeTypeParseException("Sub type is invalid."); } /** * Retrieve the primary type of this object. * * @return the primary MIME type */ public String getPrimaryType() { return primaryType; } /** * Set the primary type for this object to the given String. * * @param primary the primary MIME type * @exception MimeTypeParseException if the primary type * is not a valid token */ public void setPrimaryType(String primary) throws MimeTypeParseException { // check to see if primary is valid if (!isValidToken(primaryType)) throw new MimeTypeParseException("Primary type is invalid."); primaryType = primary.toLowerCase(Locale.ENGLISH); } /** * Retrieve the subtype of this object. * * @return the MIME subtype */ public String getSubType() { return subType; } /** * Set the subtype for this object to the given String. * * @param sub the MIME subtype * @exception MimeTypeParseException if the subtype * is not a valid token */ public void setSubType(String sub) throws MimeTypeParseException { // check to see if sub is valid if (!isValidToken(subType)) throw new MimeTypeParseException("Sub type is invalid."); subType = sub.toLowerCase(Locale.ENGLISH); } /** * Retrieve this object's parameter list. * * @return a MimeTypeParameterList object representing the parameters */ public MimeTypeParameterList getParameters() { return parameters; } /** * Retrieve the value associated with the given name, or null if there * is no current association. * * @param name the parameter name * @return the paramter's value */ public String getParameter(String name) { return parameters.get(name); } /** * Set the value to be associated with the given name, replacing * any previous association. * * @param name the parameter name * @param value the paramter's value */ public void setParameter(String name, String value) { parameters.set(name, value); } /** * Remove any value associated with the given name. * * @param name the parameter name */ public void removeParameter(String name) { parameters.remove(name); } /** * Return the String representation of this object. */ public String toString() { return getBaseType() + parameters.toString(); } /** * Return a String representation of this object * without the parameter list. * * @return the MIME type and sub-type */ public String getBaseType() { return primaryType + "/" + subType; } /** * Determine if the primary and sub type of this object is * the same as what is in the given type. * * @param type the MimeType object to compare with * @return true if they match */ public boolean match(MimeType type) { return primaryType.equals(type.getPrimaryType()) && (subType.equals("*") || type.getSubType().equals("*") || (subType.equals(type.getSubType()))); } /** * Determine if the primary and sub type of this object is * the same as the content type described in rawdata. * * @param rawdata the MIME type string to compare with * @return true if they match * @exception MimeTypeParseException if the MIME type can't be parsed */ public boolean match(String rawdata) throws MimeTypeParseException { return match(new MimeType(rawdata)); } /** * The object implements the writeExternal method to save its contents * by calling the methods of DataOutput for its primitive values or * calling the writeObject method of ObjectOutput for objects, strings * and arrays. * * @param out the ObjectOutput object to write to * @exception IOException Includes any I/O exceptions that may occur */ public void writeExternal(ObjectOutput out) throws IOException { out.writeUTF(toString()); out.flush(); } /** * The object implements the readExternal method to restore its * contents by calling the methods of DataInput for primitive * types and readObject for objects, strings and arrays. The * readExternal method must read the values in the same sequence * and with the same types as were written by writeExternal. * * @param in the ObjectInput object to read from * @exception ClassNotFoundException If the class for an object being * restored cannot be found. */ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { try { parse(in.readUTF()); } catch (MimeTypeParseException e) { throw new IOException(e.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); } /** * Determine whether or not a given string is a legal token. */ private boolean isValidToken(String s) { int len = s.length(); if (len > 0) { for (int i = 0; i < len; ++i) { char c = s.charAt(i); if (!isTokenChar(c)) { return false; } } return true; } else { return false; } } /** * A simple parser test, * for debugging... * public static void main(String[] args) throws MimeTypeParseException, IOException { for (int i = 0; i < args.length; ++i) { System.out.println("Original: " + args[i]); MimeType type = new MimeType(args[i]); System.out.println("Short: " + type.getBaseType()); System.out.println("Parsed: " + type.toString()); System.out.println(); } } */ }