1 /*
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package javax.activation;
27
28 import java.awt.datatransfer.DataFlavor;
29 import java.io.IOException;
30 import javax.activation.MimeType;
31
32 /**
33 * The ActivationDataFlavor class is a special subclass of
34 * <code>java.awt.datatransfer.DataFlavor</code>. It allows the JAF to
35 * set all three values stored by the DataFlavor class via a new
36 * constructor. It also contains improved MIME parsing in the <code>equals
37 * </code> method. Except for the improved parsing, its semantics are
38 * identical to that of the JDK's DataFlavor class.
39 *
40 * @since 1.6
41 */
42
43 public class ActivationDataFlavor extends DataFlavor {
44
45 /*
46 * Raison d'etre:
47 *
48 * The DataFlavor class included in JDK 1.1 has several limitations
49 * including piss poor MIME type parsing, and the limitation of
50 * only supporting serialized objects and InputStreams as
51 * representation objects. This class 'fixes' that.
52 */
53
54 // I think for now I'll keep copies of all the variables and
55 // then later I may choose try to better coexist with the base
56 // class *sigh*
57 private String mimeType = null;
58 private MimeType mimeObject = null;
59 private String humanPresentableName = null;
60 private Class representationClass = null;
61
62 /**
63 * Construct a DataFlavor that represents an arbitrary
64 * Java object. This constructor is an extension of the
65 * JDK's DataFlavor in that it allows the explicit setting
66 * of all three DataFlavor attributes.
67 * <p>
68 * The returned DataFlavor will have the following characteristics:
69 * <p>
70 * representationClass = representationClass<br>
71 * mimeType = mimeType<br>
72 * humanName = humanName
73 * <p>
74 *
75 * @param representationClass the class used in this DataFlavor
76 * @param mimeType the MIME type of the data represented by this class
77 * @param humanPresentableName the human presentable name of the flavor
78 */
79 public ActivationDataFlavor(Class representationClass,
80 String mimeType, String humanPresentableName) {
81 super(mimeType, humanPresentableName); // need to call super
82
83 // init private variables:
84 this.mimeType = mimeType;
85 this.humanPresentableName = humanPresentableName;
86 this.representationClass = representationClass;
87 }
88
89 /**
90 * Construct a DataFlavor that represents a MimeType.
91 * <p>
92 * The returned DataFlavor will have the following characteristics:
93 * <p>
94 * If the mimeType is "application/x-java-serialized-object;
95 * class=", the result is the same as calling new
96 * DataFlavor(Class.forName()) as above.
97 * <p>
98 * otherwise:
99 * <p>
100 * representationClass = InputStream<p>
101 * mimeType = mimeType<p>
102 *
103 * @param representationClass the class used in this DataFlavor
104 * @param humanPresentableName the human presentable name of the flavor
105 */
106 public ActivationDataFlavor(Class representationClass,
107 String humanPresentableName) {
108 super(representationClass, humanPresentableName);
109 this.mimeType = super.getMimeType();
110 this.representationClass = representationClass;
111 this.humanPresentableName = humanPresentableName;
112 }
113
114 /**
115 * Construct a DataFlavor that represents a MimeType.
116 * <p>
117 * The returned DataFlavor will have the following characteristics:
118 * <p>
119 * If the mimeType is "application/x-java-serialized-object; class=",
120 * the result is the same as calling new DataFlavor(Class.forName()) as
121 * above, otherwise:
122 * <p>
123 * representationClass = InputStream<p>
124 * mimeType = mimeType
125 *
126 * @param mimeType the MIME type of the data represented by this class
127 * @param humanPresentableName the human presentable name of the flavor
128 */
129 public ActivationDataFlavor(String mimeType, String humanPresentableName) {
130 super(mimeType, humanPresentableName);
131 this.mimeType = mimeType;
132 try {
133 this.representationClass = Class.forName("java.io.InputStream");
134 } catch (ClassNotFoundException ex) {
135 // XXX - should never happen, ignore it
136 }
137 this.humanPresentableName = humanPresentableName;
138 }
139
140 /**
141 * Return the MIME type for this DataFlavor.
142 *
143 * @return the MIME type
144 */
145 public String getMimeType() {
146 return mimeType;
147 }
148
149 /**
150 * Return the representation class.
151 *
152 * @return the representation class
153 */
154 public Class getRepresentationClass() {
155 return representationClass;
156 }
157
158 /**
159 * Return the Human Presentable name.
160 *
161 * @return the human presentable name
162 */
163 public String getHumanPresentableName() {
164 return humanPresentableName;
165 }
166
167 /**
168 * Set the human presentable name.
169 *
170 * @param humanPresentableName the name to set
171 */
172 public void setHumanPresentableName(String humanPresentableName) {
173 this.humanPresentableName = humanPresentableName;
174 }
175
176 /**
177 * Compares the DataFlavor passed in with this DataFlavor; calls
178 * the <code>isMimeTypeEqual</code> method.
179 *
180 * @param dataFlavor the DataFlavor to compare with
181 * @return true if the MIME type and representation class
182 * are the same
183 */
184 public boolean equals(DataFlavor dataFlavor) {
185 return (isMimeTypeEqual(dataFlavor) &&
186 dataFlavor.getRepresentationClass() == representationClass);
187 }
188
189 /**
190 * Is the string representation of the MIME type passed in equivalent
191 * to the MIME type of this DataFlavor. <p>
192 *
193 * ActivationDataFlavor delegates the comparison of MIME types to
194 * the MimeType class included as part of the JavaBeans Activation
195 * Framework. This provides a more robust comparison than is normally
196 * available in the DataFlavor class.
197 *
198 * @param mimeType the MIME type
199 * @return true if the same MIME type
200 */
201 public boolean isMimeTypeEqual(String mimeType) {
202 MimeType mt = null;
203 try {
204 if (mimeObject == null)
205 mimeObject = new MimeType(this.mimeType);
206 mt = new MimeType(mimeType);
207 } catch (MimeTypeParseException e) {
208 // something didn't parse, do a crude comparison
209 return this.mimeType.equalsIgnoreCase(mimeType);
210 }
211
212 return mimeObject.match(mt);
213 }
214
215 /**
216 * Called on DataFlavor for every MIME Type parameter to allow DataFlavor
217 * subclasses to handle special parameters like the text/plain charset
218 * parameters, whose values are case insensitive. (MIME type parameter
219 * values are supposed to be case sensitive).
220 * <p>
221 * This method is called for each parameter name/value pair and should
222 * return the normalized representation of the parameterValue.
223 * This method is never invoked by this implementation.
224 *
225 * @param parameterName the parameter name
226 * @param parameterValue the parameter value
227 * @return the normalized parameter value
228 * @deprecated
229 */
230 protected String normalizeMimeTypeParameter(String parameterName,
231 String parameterValue) {
232 return parameterValue;
233 }
234
235 /**
236 * Called for each MIME type string to give DataFlavor subtypes the
237 * opportunity to change how the normalization of MIME types is
238 * accomplished.
239 * One possible use would be to add default parameter/value pairs in cases
240 * where none are present in the MIME type string passed in.
241 * This method is never invoked by this implementation.
242 *
243 * @param mimeType the MIME type
244 * @return the normalized MIME type
245 * @deprecated
246 */
247 protected String normalizeMimeType(String mimeType) {
248 return mimeType;
249 }
250 }