jdk8-mips64-public/jaxws: src/share/jaf_classes/javax/activation/MimeType.java@373ffda63c9a (annotated)

src/share/jaf_classes/javax/activation/MimeType.java@373ffda63c9a (annotated)

src/share/jaf_classes/javax/activation/MimeType.java

Wed, 27 Apr 2016 01:27:09 +0800

author: aoqi
date: Wed, 27 Apr 2016 01:27:09 +0800
changeset 0: 373ffda63c9a
permissions: -rw-r--r--

Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/jaxws/
changeset: 657:d47a47f961ee
tag: jdk8u25-b17

 /*
  * 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.io.*;
 import java.util.Locale;
 /**
  * A Multipurpose Internet Mail Extension (MIME) type, as defined
  * in RFC 2045 and 2046.
  *
  * @since 1.6
  */
 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
      */
     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
      */
     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();
         }
     }
     */
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaf_classes/javax/activation/MimeType.java@373ffda63c9a (annotated)

src/share/jaf_classes/javax/activation/MimeType.java