/*

* Copyright (c) 1997, 2002, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

package java.awt.datatransfer;

import java.io.Externalizable;

import java.io.ObjectOutput;

import java.io.ObjectInput;

import java.io.IOException;

import java.util.Enumeration;

/**

* A Multipurpose Internet Mail Extension (MIME) type, as defined

* in RFC 2045 and 2046.

*

* THIS IS *NOT* - REPEAT *NOT* - A PUBLIC CLASS! DataFlavor IS

* THE PUBLIC INTERFACE, AND THIS IS PROVIDED AS A ***PRIVATE***

* (THAT IS AS IN *NOT* PUBLIC) HELPER CLASS!

*/

class MimeType implements Externalizable, Cloneable {

/*

* serialization support

*/

static final long serialVersionUID = -6568722458793895906L;

/**

* Constructor for externalization; this constructor should not be

* called directly by an application, since the result will be an

* uninitialized, immutable <code>MimeType</code> object.

*/

public MimeType() {

}

/**

* Builds a <code>MimeType</code> from a <code>String</code>.

*

* @param rawdata text used to initialize the <code>MimeType</code>

* @throws NullPointerException if <code>rawdata</code> is null

*/

public MimeType(String rawdata) throws MimeTypeParseException {

parse(rawdata);

}

/**

* Builds a <code>MimeType</code> with the given primary and sub

* type but has an empty parameter list.

*

* @param primary the primary type of this <code>MimeType</code>

* @param sub the subtype of this <code>MimeType</code>

* @throws NullPointerException if either <code>primary</code> or

* <code>sub</code> is null

*/

public MimeType(String primary, String sub) throws MimeTypeParseException {

this(primary, sub, new MimeTypeParameterList());

}

/**

* Builds a <code>MimeType</code> with a pre-defined

* and valid (or empty) parameter list.

*

* @param primary the primary type of this <code>MimeType</code>

* @param sub the subtype of this <code>MimeType</code>

* @param mtpl the requested parameter list

* @throws NullPointerException if either <code>primary</code>,

* <code>sub</code> or <code>mtpl</code> is null

*/

public MimeType(String primary, String sub, MimeTypeParameterList mtpl) throws

MimeTypeParseException {

// check to see if primary is valid

if(isValidToken(primary)) {

primaryType = primary.toLowerCase();

} else {

throw new MimeTypeParseException("Primary type is invalid.");

}

// check to see if sub is valid

if(isValidToken(sub)) {

subType = sub.toLowerCase();

} else {

throw new MimeTypeParseException("Sub type is invalid.");

}

parameters = (MimeTypeParameterList)mtpl.clone();

}

public int hashCode() {

// We sum up the hash codes for all of the strings. This

// way, the order of the strings is irrelevant

int code = 0;

code += primaryType.hashCode();

code += subType.hashCode();

code += parameters.hashCode();

return code;

} // hashCode()

/**

* <code>MimeType</code>s are equal if their primary types,

* subtypes, and parameters are all equal. No default values

* are taken into account.

* @param thatObject the object to be evaluated as a

* <code>MimeType</code>

* @return <code>true</code> if <code>thatObject</code> is

* a <code>MimeType</code>; otherwise returns <code>false</code>

*/

public boolean equals(Object thatObject) {

if (!(thatObject instanceof MimeType)) {

return false;

}

MimeType that = (MimeType)thatObject;

boolean isIt =

((this.primaryType.equals(that.primaryType)) &&

(this.subType.equals(that.subType)) &&

(this.parameters.equals(that.parameters)));

return isIt;

} // equals()

/**

* A routine for parsing the MIME type out of a String.

*

* @throws NullPointerException if <code>rawdata</code> is null

*/

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();

subType = rawdata.substring(slashIndex +

1).trim().toLowerCase();

parameters = new MimeTypeParameterList();

} else if (slashIndex < semIndex) {

// we have all three items in the proper sequence

primaryType = rawdata.substring(0,

slashIndex).trim().toLowerCase();

subType = rawdata.substring(slashIndex + 1,

semIndex).trim().toLowerCase();

parameters = new

MimeTypeParameterList(rawdata.substring(semIndex));

} else {

// we have a ';' lexically before a '/' which means we have a primary type

// & 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.

*/

public String getPrimaryType() {

return primaryType;

}

/**

* Retrieve the sub type of this object.

*/

public String getSubType() {

return subType;

}

/**

* Retrieve a copy of this object's parameter list.

*/

public MimeTypeParameterList getParameters() {

return (MimeTypeParameterList)parameters.clone();

}

/**

* Retrieve the value associated with the given name, or null if there

* is no current association.

*/

public String getParameter(String name) {

return parameters.get(name);

}

/**

* Set the value to be associated with the given name, replacing

* any previous association.

*

* @throw IllegalArgumentException if parameter or value is illegal

*/

public void setParameter(String name, String value) {

parameters.set(name, value);

}

/**

* Remove any value associated with the given name.

*

* @throw IllegalArgumentExcpetion if parameter may not be deleted

*/

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.

*/

public String getBaseType() {

return primaryType + "/" + subType;

}

/**

* Returns <code>true</code> if the primary type and the

* subtype of this object are the same as the specified

* <code>type</code>; otherwise returns <code>false</code>.

*

* @param type the type to compare to <code>this</code>'s type

* @return <code>true</code> if the primary type and the

* subtype of this object are the same as the

* specified <code>type</code>; otherwise returns

* <code>false</code>

*/

public boolean match(MimeType type) {

if (type == null)

return false;

return primaryType.equals(type.getPrimaryType())

&& (subType.equals("*")

|| type.getSubType().equals("*")

|| (subType.equals(type.getSubType())));

}

/**

* Returns <code>true</code> if the primary type and the

* subtype of this object are the same as the content type

* described in <code>rawdata</code>; otherwise returns

* <code>false</code>.

*

* @param rawdata the raw data to be examined

* @return <code>true</code> if the primary type and the

* subtype of this object are the same as the content type

* described in <code>rawdata</code>; otherwise returns

* <code>false</code>; if <code>rawdata</code> is

* <code>null</code>, returns <code>false</code>

*/

public boolean match(String rawdata) throws MimeTypeParseException {

if (rawdata == null)

return false;

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.

* @exception IOException Includes any I/O exceptions that may occur

*/

public void writeExternal(ObjectOutput out) throws IOException {

String s = toString(); // contains ASCII chars only

// one-to-one correspondence between ASCII char and byte in UTF string

if (s.length() <= 65535) { // 65535 is max length of UTF string

out.writeUTF(s);

} else {

out.writeByte(0);

out.writeByte(0);

out.writeInt(s.length());

out.write(s.getBytes());

}

}

/**

* 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.

* @exception ClassNotFoundException If the class for an object being

* restored cannot be found.

*/

public void readExternal(ObjectInput in) throws IOException,

ClassNotFoundException {

String s = in.readUTF();

if (s == null || s.length() == 0) { // long mime type

byte[] ba = new byte[in.readInt()];

in.readFully(ba);

s = new String(ba);

}

try {

parse(s);

} catch(MimeTypeParseException e) {

throw new IOException(e.toString());

}

}

/**

* Returns a clone of this object.

* @return a clone of this object

*/

public Object clone() {

MimeType newObj = null;

try {

newObj = (MimeType)super.clone();

} catch (CloneNotSupportedException cannotHappen) {

}

newObj.parameters = (MimeTypeParameterList)parameters.clone();

return newObj;

}

private String primaryType;

private String subType;

private MimeTypeParameterList parameters;

// below here be scary parsing related things

/**

* Determines 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);

}

/**

* Determines whether or not a given string is a legal token.

*

* @throws NullPointerException if <code>s</code> is null

*/

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 string that holds all the special chars.

*/

private static final String TSPECIALS = "()<>@,;:\\\"/[]?=";

} // class MimeType