251 lines
9.0 KiB
Java
251 lines
9.0 KiB
Java
/*
|
|
* 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.awt.datatransfer.DataFlavor;
|
|
import java.io.IOException;
|
|
import javax.activation.MimeType;
|
|
|
|
/**
|
|
* The ActivationDataFlavor class is a special subclass of
|
|
* <code>java.awt.datatransfer.DataFlavor</code>. It allows the JAF to
|
|
* set all three values stored by the DataFlavor class via a new
|
|
* constructor. It also contains improved MIME parsing in the <code>equals
|
|
* </code> method. Except for the improved parsing, its semantics are
|
|
* identical to that of the JDK's DataFlavor class.
|
|
*
|
|
* @since 1.6
|
|
*/
|
|
|
|
public class ActivationDataFlavor extends DataFlavor {
|
|
|
|
/*
|
|
* Raison d'etre:
|
|
*
|
|
* The DataFlavor class included in JDK 1.1 has several limitations
|
|
* including piss poor MIME type parsing, and the limitation of
|
|
* only supporting serialized objects and InputStreams as
|
|
* representation objects. This class 'fixes' that.
|
|
*/
|
|
|
|
// I think for now I'll keep copies of all the variables and
|
|
// then later I may choose try to better coexist with the base
|
|
// class *sigh*
|
|
private String mimeType = null;
|
|
private MimeType mimeObject = null;
|
|
private String humanPresentableName = null;
|
|
private Class representationClass = null;
|
|
|
|
/**
|
|
* Construct a DataFlavor that represents an arbitrary
|
|
* Java object. This constructor is an extension of the
|
|
* JDK's DataFlavor in that it allows the explicit setting
|
|
* of all three DataFlavor attributes.
|
|
* <p>
|
|
* The returned DataFlavor will have the following characteristics:
|
|
* <p>
|
|
* representationClass = representationClass<br>
|
|
* mimeType = mimeType<br>
|
|
* humanName = humanName
|
|
* <p>
|
|
*
|
|
* @param representationClass the class used in this DataFlavor
|
|
* @param mimeType the MIME type of the data represented by this class
|
|
* @param humanPresentableName the human presentable name of the flavor
|
|
*/
|
|
public ActivationDataFlavor(Class representationClass,
|
|
String mimeType, String humanPresentableName) {
|
|
super(mimeType, humanPresentableName); // need to call super
|
|
|
|
// init private variables:
|
|
this.mimeType = mimeType;
|
|
this.humanPresentableName = humanPresentableName;
|
|
this.representationClass = representationClass;
|
|
}
|
|
|
|
/**
|
|
* Construct a DataFlavor that represents a MimeType.
|
|
* <p>
|
|
* The returned DataFlavor will have the following characteristics:
|
|
* <p>
|
|
* If the mimeType is "application/x-java-serialized-object;
|
|
* class=", the result is the same as calling new
|
|
* DataFlavor(Class.forName()) as above.
|
|
* <p>
|
|
* otherwise:
|
|
* <p>
|
|
* representationClass = InputStream<p>
|
|
* mimeType = mimeType<p>
|
|
*
|
|
* @param representationClass the class used in this DataFlavor
|
|
* @param humanPresentableName the human presentable name of the flavor
|
|
*/
|
|
public ActivationDataFlavor(Class representationClass,
|
|
String humanPresentableName) {
|
|
super(representationClass, humanPresentableName);
|
|
this.mimeType = super.getMimeType();
|
|
this.representationClass = representationClass;
|
|
this.humanPresentableName = humanPresentableName;
|
|
}
|
|
|
|
/**
|
|
* Construct a DataFlavor that represents a MimeType.
|
|
* <p>
|
|
* The returned DataFlavor will have the following characteristics:
|
|
* <p>
|
|
* If the mimeType is "application/x-java-serialized-object; class=",
|
|
* the result is the same as calling new DataFlavor(Class.forName()) as
|
|
* above, otherwise:
|
|
* <p>
|
|
* representationClass = InputStream<p>
|
|
* mimeType = mimeType
|
|
*
|
|
* @param mimeType the MIME type of the data represented by this class
|
|
* @param humanPresentableName the human presentable name of the flavor
|
|
*/
|
|
public ActivationDataFlavor(String mimeType, String humanPresentableName) {
|
|
super(mimeType, humanPresentableName);
|
|
this.mimeType = mimeType;
|
|
try {
|
|
this.representationClass = Class.forName("java.io.InputStream");
|
|
} catch (ClassNotFoundException ex) {
|
|
// XXX - should never happen, ignore it
|
|
}
|
|
this.humanPresentableName = humanPresentableName;
|
|
}
|
|
|
|
/**
|
|
* Return the MIME type for this DataFlavor.
|
|
*
|
|
* @return the MIME type
|
|
*/
|
|
public String getMimeType() {
|
|
return mimeType;
|
|
}
|
|
|
|
/**
|
|
* Return the representation class.
|
|
*
|
|
* @return the representation class
|
|
*/
|
|
public Class getRepresentationClass() {
|
|
return representationClass;
|
|
}
|
|
|
|
/**
|
|
* Return the Human Presentable name.
|
|
*
|
|
* @return the human presentable name
|
|
*/
|
|
public String getHumanPresentableName() {
|
|
return humanPresentableName;
|
|
}
|
|
|
|
/**
|
|
* Set the human presentable name.
|
|
*
|
|
* @param humanPresentableName the name to set
|
|
*/
|
|
public void setHumanPresentableName(String humanPresentableName) {
|
|
this.humanPresentableName = humanPresentableName;
|
|
}
|
|
|
|
/**
|
|
* Compares the DataFlavor passed in with this DataFlavor; calls
|
|
* the <code>isMimeTypeEqual</code> method.
|
|
*
|
|
* @param dataFlavor the DataFlavor to compare with
|
|
* @return true if the MIME type and representation class
|
|
* are the same
|
|
*/
|
|
public boolean equals(DataFlavor dataFlavor) {
|
|
return (isMimeTypeEqual(dataFlavor) &&
|
|
dataFlavor.getRepresentationClass() == representationClass);
|
|
}
|
|
|
|
/**
|
|
* Is the string representation of the MIME type passed in equivalent
|
|
* to the MIME type of this DataFlavor. <p>
|
|
*
|
|
* ActivationDataFlavor delegates the comparison of MIME types to
|
|
* the MimeType class included as part of the JavaBeans Activation
|
|
* Framework. This provides a more robust comparison than is normally
|
|
* available in the DataFlavor class.
|
|
*
|
|
* @param mimeType the MIME type
|
|
* @return true if the same MIME type
|
|
*/
|
|
public boolean isMimeTypeEqual(String mimeType) {
|
|
MimeType mt = null;
|
|
try {
|
|
if (mimeObject == null)
|
|
mimeObject = new MimeType(this.mimeType);
|
|
mt = new MimeType(mimeType);
|
|
} catch (MimeTypeParseException e) {
|
|
// something didn't parse, do a crude comparison
|
|
return this.mimeType.equalsIgnoreCase(mimeType);
|
|
}
|
|
|
|
return mimeObject.match(mt);
|
|
}
|
|
|
|
/**
|
|
* Called on DataFlavor for every MIME Type parameter to allow DataFlavor
|
|
* subclasses to handle special parameters like the text/plain charset
|
|
* parameters, whose values are case insensitive. (MIME type parameter
|
|
* values are supposed to be case sensitive).
|
|
* <p>
|
|
* This method is called for each parameter name/value pair and should
|
|
* return the normalized representation of the parameterValue.
|
|
* This method is never invoked by this implementation.
|
|
*
|
|
* @param parameterName the parameter name
|
|
* @param parameterValue the parameter value
|
|
* @return the normalized parameter value
|
|
* @deprecated
|
|
*/
|
|
protected String normalizeMimeTypeParameter(String parameterName,
|
|
String parameterValue) {
|
|
return parameterValue;
|
|
}
|
|
|
|
/**
|
|
* Called for each MIME type string to give DataFlavor subtypes the
|
|
* opportunity to change how the normalization of MIME types is
|
|
* accomplished.
|
|
* One possible use would be to add default parameter/value pairs in cases
|
|
* where none are present in the MIME type string passed in.
|
|
* This method is never invoked by this implementation.
|
|
*
|
|
* @param mimeType the MIME type
|
|
* @return the normalized MIME type
|
|
* @deprecated
|
|
*/
|
|
protected String normalizeMimeType(String mimeType) {
|
|
return mimeType;
|
|
}
|
|
}
|