1 /*
2 * Copyright (c) 1997, 2017, 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.io.InputStream;
29 import java.io.IOException;
30 import java.io.OutputStream;
31 import java.io.PipedInputStream;
32 import java.io.PipedOutputStream;
33 import java.io.OutputStreamWriter;
34 import java.net.URL;
35 import java.awt.datatransfer.Transferable;
36 import java.awt.datatransfer.DataFlavor;
37 import java.awt.datatransfer.UnsupportedFlavorException;
38
39 /**
40 * The DataHandler class provides a consistent interface to data
41 * available in many different sources and formats.
42 * It manages simple stream to string conversions and related operations
43 * using DataContentHandlers.
44 * It provides access to commands that can operate on the data.
45 * The commands are found using a CommandMap. <p>
46 *
47 * <b>DataHandler and the Transferable Interface</b><p>
48 * DataHandler implements the Transferable interface so that data can
49 * be used in AWT data transfer operations, such as cut and paste and
50 * drag and drop. The implementation of the Transferable interface
51 * relies on the availability of an installed DataContentHandler
52 * object corresponding to the MIME type of the data represented in
53 * the specific instance of the DataHandler.<p>
54 *
55 * <b>DataHandler and CommandMaps</b><p>
56 * The DataHandler keeps track of the current CommandMap that it uses to
57 * service requests for commands ({@code getCommand, getAllCommands,
58 * getPreferredCommands}).
59 * Each instance of a DataHandler may have a CommandMap associated with
60 * it using the {@code setCommandMap} method. If a CommandMap was
61 * not set, DataHandler calls the {@code getDefaultCommandMap}
62 * method in CommandMap and uses the value it returns. See
63 * <i>CommandMap</i> for more information. <p>
64 *
65 * <b>DataHandler and URLs</b><p>
66 * The current DataHandler implementation creates a private
67 * instance of URLDataSource when it is constructed with a URL.
68 *
69 * @see javax.activation.CommandMap
70 * @see javax.activation.DataContentHandler
71 * @see javax.activation.DataSource
72 * @see javax.activation.URLDataSource
73 *
74 * @since 1.6
75 */
76
77 public class DataHandler implements Transferable {
78
79 // Use the datasource to indicate whether we were started via the
80 // DataSource constructor or the object constructor.
81 private DataSource dataSource = null;
82 private DataSource objDataSource = null;
83
84 // The Object and mimetype from the constructor (if passed in).
85 // object remains null if it was instantiated with a
86 // DataSource.
87 private Object object = null;
88 private String objectMimeType = null;
89
90 // Keep track of the CommandMap
91 private CommandMap currentCommandMap = null;
92
93 // our transfer flavors
94 private static final DataFlavor emptyFlavors[] = new DataFlavor[0];
95 private DataFlavor transferFlavors[] = emptyFlavors;
96
97 // our DataContentHandler
98 private DataContentHandler dataContentHandler = null;
99 private DataContentHandler factoryDCH = null;
100
101 // our DataContentHandlerFactory
102 private static DataContentHandlerFactory factory = null;
103 private DataContentHandlerFactory oldFactory = null;
104 // the short representation of the ContentType (sans params)
105 private String shortType = null;
106
107 /**
108 * Create a {@code DataHandler} instance referencing the
109 * specified DataSource. The data exists in a byte stream form.
110 * The DataSource will provide an InputStream to access the data.
111 *
112 * @param ds the DataSource
113 */
114 public DataHandler(DataSource ds) {
115 // save a reference to the incoming DS
116 dataSource = ds;
117 oldFactory = factory; // keep track of the factory
118 }
119
120 /**
121 * Create a {@code DataHandler} instance representing an object
122 * of this MIME type. This constructor is
123 * used when the application already has an in-memory representation
124 * of the data in the form of a Java Object.
125 *
126 * @param obj the Java Object
127 * @param mimeType the MIME type of the object
128 */
129 public DataHandler(Object obj, String mimeType) {
130 object = obj;
131 objectMimeType = mimeType;
132 oldFactory = factory; // keep track of the factory
133 }
134
135 /**
136 * Create a {@code DataHandler} instance referencing a URL.
137 * The DataHandler internally creates a {@code URLDataSource}
138 * instance to represent the URL.
139 *
140 * @param url a URL object
141 */
142 public DataHandler(URL url) {
143 dataSource = new URLDataSource(url);
144 oldFactory = factory; // keep track of the factory
145 }
146
147 /**
148 * Return the CommandMap for this instance of DataHandler.
149 */
150 private synchronized CommandMap getCommandMap() {
151 if (currentCommandMap != null)
152 return currentCommandMap;
153 else
154 return CommandMap.getDefaultCommandMap();
155 }
156
157 /**
158 * Return the DataSource associated with this instance
159 * of DataHandler.
160 * <p>
161 * For DataHandlers that have been instantiated with a DataSource,
162 * this method returns the DataSource that was used to create the
163 * DataHandler object. In other cases the DataHandler
164 * constructs a DataSource from the data used to construct
165 * the DataHandler. DataSources created for DataHandlers <b>not</b>
166 * instantiated with a DataSource are cached for performance
167 * reasons.
168 *
169 * @return a valid DataSource object for this DataHandler
170 */
171 public DataSource getDataSource() {
172 if (dataSource == null) {
173 // create one on the fly
174 if (objDataSource == null)
175 objDataSource = new DataHandlerDataSource(this);
176 return objDataSource;
177 }
178 return dataSource;
179 }
180
181 /**
182 * Return the name of the data object. If this DataHandler
183 * was created with a DataSource, this method calls through
184 * to the {@code DataSource.getName} method, otherwise it
185 * returns <i>null</i>.
186 *
187 * @return the name of the object
188 */
189 public String getName() {
190 if (dataSource != null)
191 return dataSource.getName();
192 else
193 return null;
194 }
195
196 /**
197 * Return the MIME type of this object as retrieved from
198 * the source object. Note that this is the <i>full</i>
199 * type with parameters.
200 *
201 * @return the MIME type
202 */
203 public String getContentType() {
204 if (dataSource != null) // data source case
205 return dataSource.getContentType();
206 else
207 return objectMimeType; // obj/type case
208 }
209
210 /**
211 * Get the InputStream for this object. <p>
212 *
213 * For DataHandlers instantiated with a DataSource, the DataHandler
214 * calls the {@code DataSource.getInputStream} method and
215 * returns the result to the caller.
216 * <p>
217 * For DataHandlers instantiated with an Object, the DataHandler
218 * first attempts to find a DataContentHandler for the Object. If
219 * the DataHandler can not find a DataContentHandler for this MIME
220 * type, it throws an UnsupportedDataTypeException. If it is
221 * successful, it creates a pipe and a thread. The thread uses the
222 * DataContentHandler's {@code writeTo} method to write the
223 * stream data into one end of the pipe. The other end of the pipe
224 * is returned to the caller. Because a thread is created to copy
225 * the data, IOExceptions that may occur during the copy can not be
226 * propagated back to the caller. The result is an empty stream.
227 *
228 * @return the InputStream representing this data
229 * @exception IOException if an I/O error occurs
230 *
231 * @see javax.activation.DataContentHandler#writeTo
232 * @see javax.activation.UnsupportedDataTypeException
233 */
234 public InputStream getInputStream() throws IOException {
235 InputStream ins = null;
236
237 if (dataSource != null) {
238 ins = dataSource.getInputStream();
239 } else {
240 DataContentHandler dch = getDataContentHandler();
241 // we won't even try if we can't get a dch
242 if (dch == null)
243 throw new UnsupportedDataTypeException(
244 "no DCH for MIME type " + getBaseType());
245
246 if (dch instanceof ObjectDataContentHandler) {
247 if (((ObjectDataContentHandler)dch).getDCH() == null)
248 throw new UnsupportedDataTypeException(
249 "no object DCH for MIME type " + getBaseType());
250 }
251 // there is none but the default^^^^^^^^^^^^^^^^
252 final DataContentHandler fdch = dch;
253
254 // from bill s.
255 // ce n'est pas une pipe!
256 //
257 // NOTE: This block of code needs to throw exceptions, but
258 // can't because it is in another thread!!! ARG!
259 //
260 final PipedOutputStream pos = new PipedOutputStream();
261 PipedInputStream pin = new PipedInputStream(pos);
262 new Thread(
263 new Runnable() {
264 public void run() {
265 try {
266 fdch.writeTo(object, objectMimeType, pos);
267 } catch (IOException e) {
268
269 } finally {
270 try {
271 pos.close();
272 } catch (IOException ie) { }
273 }
274 }
275 },
276 "DataHandler.getInputStream").start();
277 ins = pin;
278 }
279
280 return ins;
281 }
282
283 /**
284 * Write the data to an {@code OutputStream}.<p>
285 *
286 * If the DataHandler was created with a DataSource, writeTo
287 * retrieves the InputStream and copies the bytes from the
288 * InputStream to the OutputStream passed in.
289 * <p>
290 * If the DataHandler was created with an object, writeTo
291 * retrieves the DataContentHandler for the object's type.
292 * If the DataContentHandler was found, it calls the
293 * {@code writeTo} method on the {@code DataContentHandler}.
294 *
295 * @param os the OutputStream to write to
296 * @exception IOException if an I/O error occurs
297 */
298 public void writeTo(OutputStream os) throws IOException {
299 // for the DataSource case
300 if (dataSource != null) {
301 InputStream is = null;
302 byte data[] = new byte[8*1024];
303 int bytes_read;
304
305 is = dataSource.getInputStream();
306
307 try {
308 while ((bytes_read = is.read(data)) > 0) {
309 os.write(data, 0, bytes_read);
310 }
311 } finally {
312 is.close();
313 is = null;
314 }
315 } else { // for the Object case
316 DataContentHandler dch = getDataContentHandler();
317 dch.writeTo(object, objectMimeType, os);
318 }
319 }
320
321 /**
322 * Get an OutputStream for this DataHandler to allow overwriting
323 * the underlying data.
324 * If the DataHandler was created with a DataSource, the
325 * DataSource's {@code getOutputStream} method is called.
326 * Otherwise, {@code null} is returned.
327 *
328 * @return the OutputStream
329 * @exception IOException for failures creating the OutputStream
330 *
331 * @see javax.activation.DataSource#getOutputStream
332 * @see javax.activation.URLDataSource
333 */
334 public OutputStream getOutputStream() throws IOException {
335 if (dataSource != null)
336 return dataSource.getOutputStream();
337 else
338 return null;
339 }
340
341 /**
342 * Return the DataFlavors in which this data is available. <p>
343 *
344 * Returns an array of DataFlavor objects indicating the flavors
345 * the data can be provided in. The array is usually ordered
346 * according to preference for providing the data, from most
347 * richly descriptive to least richly descriptive.<p>
348 *
349 * The DataHandler attempts to find a DataContentHandler that
350 * corresponds to the MIME type of the data. If one is located,
351 * the DataHandler calls the DataContentHandler's
352 * {@code getTransferDataFlavors} method. <p>
353 *
354 * If a DataContentHandler can <i>not</i> be located, and if the
355 * DataHandler was created with a DataSource (or URL), one
356 * DataFlavor is returned that represents this object's MIME type
357 * and the {@code java.io.InputStream} class. If the
358 * DataHandler was created with an object and a MIME type,
359 * getTransferDataFlavors returns one DataFlavor that represents
360 * this object's MIME type and the object's class.
361 *
362 * @return an array of data flavors in which this data can be transferred
363 * @see javax.activation.DataContentHandler#getTransferDataFlavors
364 */
365 public synchronized DataFlavor[] getTransferDataFlavors() {
366 if (factory != oldFactory) // if the factory has changed, clear cache
367 transferFlavors = emptyFlavors;
368
369 // if it's not set, set it...
370 if (transferFlavors == emptyFlavors)
371 transferFlavors = getDataContentHandler().getTransferDataFlavors();
372
373 if (transferFlavors == emptyFlavors)
374 return transferFlavors;
375 else
376 return transferFlavors.clone();
377
378 }
379
380 /**
381 * Returns whether the specified data flavor is supported
382 * for this object.<p>
383 *
384 * This method iterates through the DataFlavors returned from
385 * {@code getTransferDataFlavors}, comparing each with
386 * the specified flavor.
387 *
388 * @param flavor the requested flavor for the data
389 * @return true if the data flavor is supported
390 * @see javax.activation.DataHandler#getTransferDataFlavors
391 */
392 public boolean isDataFlavorSupported(DataFlavor flavor) {
393 DataFlavor[] lFlavors = getTransferDataFlavors();
394
395 for (int i = 0; i < lFlavors.length; i++) {
396 if (lFlavors[i].equals(flavor))
397 return true;
398 }
399 return false;
400 }
401
402 /**
403 * Returns an object that represents the data to be
404 * transferred. The class of the object returned is defined by the
405 * representation class of the data flavor.<p>
406 *
407 * <b>For DataHandler's created with DataSources or URLs:</b><p>
408 *
409 * The DataHandler attempts to locate a DataContentHandler
410 * for this MIME type. If one is found, the passed in DataFlavor
411 * and the type of the data are passed to its {@code getTransferData}
412 * method. If the DataHandler fails to locate a DataContentHandler
413 * and the flavor specifies this object's MIME type and the
414 * {@code java.io.InputStream} class, this object's InputStream
415 * is returned.
416 * Otherwise it throws an UnsupportedFlavorException. <p>
417 *
418 * <b>For DataHandler's created with Objects:</b><p>
419 *
420 * The DataHandler attempts to locate a DataContentHandler
421 * for this MIME type. If one is found, the passed in DataFlavor
422 * and the type of the data are passed to its getTransferData
423 * method. If the DataHandler fails to locate a DataContentHandler
424 * and the flavor specifies this object's MIME type and its class,
425 * this DataHandler's referenced object is returned.
426 * Otherwise it throws an UnsupportedFlavorException.
427 *
428 * @param flavor the requested flavor for the data
429 * @return the object
430 * @exception UnsupportedFlavorException if the data could not be
431 * converted to the requested flavor
432 * @exception IOException if an I/O error occurs
433 * @see javax.activation.ActivationDataFlavor
434 */
435 public Object getTransferData(DataFlavor flavor)
436 throws UnsupportedFlavorException, IOException {
437 return getDataContentHandler().getTransferData(flavor, dataSource);
438 }
439
440 /**
441 * Set the CommandMap for use by this DataHandler.
442 * Setting it to {@code null} causes the CommandMap to revert
443 * to the CommandMap returned by the
444 * {@code CommandMap.getDefaultCommandMap} method.
445 * Changing the CommandMap, or setting it to {@code null},
446 * clears out any data cached from the previous CommandMap.
447 *
448 * @param commandMap the CommandMap to use in this DataHandler
449 *
450 * @see javax.activation.CommandMap#setDefaultCommandMap
451 */
452 public synchronized void setCommandMap(CommandMap commandMap) {
453 if (commandMap != currentCommandMap || commandMap == null) {
454 // clear cached values...
455 transferFlavors = emptyFlavors;
456 dataContentHandler = null;
457
458 currentCommandMap = commandMap;
459 }
460 }
461
462 /**
463 * Return the <i>preferred</i> commands for this type of data.
464 * This method calls the {@code getPreferredCommands} method
465 * in the CommandMap associated with this instance of DataHandler.
466 * This method returns an array that represents a subset of
467 * available commands. In cases where multiple commands for the
468 * MIME type represented by this DataHandler are present, the
469 * installed CommandMap chooses the appropriate commands.
470 *
471 * @return the CommandInfo objects representing the preferred commands
472 *
473 * @see javax.activation.CommandMap#getPreferredCommands
474 */
475 public CommandInfo[] getPreferredCommands() {
476 if (dataSource != null)
477 return getCommandMap().getPreferredCommands(getBaseType(),
478 dataSource);
479 else
480 return getCommandMap().getPreferredCommands(getBaseType());
481 }
482
483 /**
484 * Return all the commands for this type of data.
485 * This method returns an array containing all commands
486 * for the type of data represented by this DataHandler. The
487 * MIME type for the underlying data represented by this DataHandler
488 * is used to call through to the {@code getAllCommands} method
489 * of the CommandMap associated with this DataHandler.
490 *
491 * @return the CommandInfo objects representing all the commands
492 *
493 * @see javax.activation.CommandMap#getAllCommands
494 */
495 public CommandInfo[] getAllCommands() {
496 if (dataSource != null)
497 return getCommandMap().getAllCommands(getBaseType(), dataSource);
498 else
499 return getCommandMap().getAllCommands(getBaseType());
500 }
501
502 /**
503 * Get the command <i>cmdName</i>. Use the search semantics as
504 * defined by the CommandMap installed in this DataHandler. The
505 * MIME type for the underlying data represented by this DataHandler
506 * is used to call through to the {@code getCommand} method
507 * of the CommandMap associated with this DataHandler.
508 *
509 * @param cmdName the command name
510 * @return the CommandInfo corresponding to the command
511 *
512 * @see javax.activation.CommandMap#getCommand
513 */
514 public CommandInfo getCommand(String cmdName) {
515 if (dataSource != null)
516 return getCommandMap().getCommand(getBaseType(), cmdName,
517 dataSource);
518 else
519 return getCommandMap().getCommand(getBaseType(), cmdName);
520 }
521
522 /**
523 * Return the data in its preferred Object form. <p>
524 *
525 * If the DataHandler was instantiated with an object, return
526 * the object. <p>
527 *
528 * If the DataHandler was instantiated with a DataSource,
529 * this method uses a DataContentHandler to return the content
530 * object for the data represented by this DataHandler. If no
531 * {@code DataContentHandler} can be found for the
532 * the type of this data, the DataHandler returns an
533 * InputStream for the data.
534 *
535 * @return the content.
536 * @exception IOException if an IOException occurs during
537 * this operation.
538 */
539 public Object getContent() throws IOException {
540 if (object != null)
541 return object;
542 else
543 return getDataContentHandler().getContent(getDataSource());
544 }
545
546 /**
547 * A convenience method that takes a CommandInfo object
548 * and instantiates the corresponding command, usually
549 * a JavaBean component.
550 * <p>
551 * This method calls the CommandInfo's {@code getCommandObject}
552 * method with the {@code ClassLoader} used to load
553 * the {@code javax.activation.DataHandler} class itself.
554 *
555 * @param cmdinfo the CommandInfo corresponding to a command
556 * @return the instantiated command object
557 */
558 public Object getBean(CommandInfo cmdinfo) {
559 Object bean = null;
560
561 try {
562 // make the bean
563 ClassLoader cld = null;
564 // First try the "application's" class loader.
565 cld = SecuritySupport.getContextClassLoader();
566 if (cld == null)
567 cld = this.getClass().getClassLoader();
568 bean = cmdinfo.getCommandObject(this, cld);
569 } catch (IOException e) {
570 } catch (ClassNotFoundException e) { }
571
572 return bean;
573 }
574
575 /**
576 * Get the DataContentHandler for this DataHandler: <p>
577 *
578 * If a DataContentHandlerFactory is set, use it.
579 * Otherwise look for an object to serve DCH in the
580 * following order: <p>
581 *
582 * 1) if a factory is set, use it <p>
583 * 2) if a CommandMap is set, use it <p>
584 * 3) use the default CommandMap <p>
585 *
586 * In any case, wrap the real DataContentHandler with one of our own
587 * to handle any missing cases, fill in defaults, and to ensure that
588 * we always have a non-null DataContentHandler.
589 *
590 * @return the requested DataContentHandler
591 */
592 private synchronized DataContentHandler getDataContentHandler() {
593
594 // make sure the factory didn't change
595 if (factory != oldFactory) {
596 oldFactory = factory;
597 factoryDCH = null;
598 dataContentHandler = null;
599 transferFlavors = emptyFlavors;
600 }
601
602 if (dataContentHandler != null)
603 return dataContentHandler;
604
605 String simpleMT = getBaseType();
606
607 if (factoryDCH == null && factory != null)
608 factoryDCH = factory.createDataContentHandler(simpleMT);
609
610 if (factoryDCH != null)
611 dataContentHandler = factoryDCH;
612
613 if (dataContentHandler == null) {
614 if (dataSource != null)
615 dataContentHandler = getCommandMap().
616 createDataContentHandler(simpleMT, dataSource);
617 else
618 dataContentHandler = getCommandMap().
619 createDataContentHandler(simpleMT);
620 }
621
622 // getDataContentHandler always uses these 'wrapper' handlers
623 // to make sure it returns SOMETHING meaningful...
624 if (dataSource != null)
625 dataContentHandler = new DataSourceDataContentHandler(
626 dataContentHandler,
627 dataSource);
628 else
629 dataContentHandler = new ObjectDataContentHandler(
630 dataContentHandler,
631 object,
632 objectMimeType);
633 return dataContentHandler;
634 }
635
636 /**
637 * Use the MimeType class to extract the MIME type/subtype,
638 * ignoring the parameters. The type is cached.
639 */
640 private synchronized String getBaseType() {
641 if (shortType == null) {
642 String ct = getContentType();
643 try {
644 MimeType mt = new MimeType(ct);
645 shortType = mt.getBaseType();
646 } catch (MimeTypeParseException e) {
647 shortType = ct;
648 }
649 }
650 return shortType;
651 }
652
653 /**
654 * Sets the DataContentHandlerFactory. The DataContentHandlerFactory
655 * is called first to find DataContentHandlers.
656 * The DataContentHandlerFactory can only be set once.
657 * <p>
658 * If the DataContentHandlerFactory has already been set,
659 * this method throws an Error.
660 *
661 * @param newFactory the DataContentHandlerFactory
662 * @exception Error if the factory has already been defined.
663 *
664 * @see javax.activation.DataContentHandlerFactory
665 */
666 public static synchronized void setDataContentHandlerFactory(
667 DataContentHandlerFactory newFactory) {
668 if (factory != null)
669 throw new Error("DataContentHandlerFactory already defined");
670
671 SecurityManager security = System.getSecurityManager();
672 if (security != null) {
673 try {
674 // if it's ok with the SecurityManager, it's ok with me...
675 security.checkSetFactory();
676 } catch (SecurityException ex) {
677 // otherwise, we also allow it if this code and the
678 // factory come from the same class loader (e.g.,
679 // the JAF classes were loaded with the applet classes).
680 if (DataHandler.class.getClassLoader() !=
681 newFactory.getClass().getClassLoader())
682 throw ex;
683 }
684 }
685 factory = newFactory;
686 }
687 }
688
689 /**
690 * The DataHanderDataSource class implements the
691 * DataSource interface when the DataHandler is constructed
692 * with an Object and a mimeType string.
693 */
694 class DataHandlerDataSource implements DataSource {
695 DataHandler dataHandler = null;
696
697 /**
698 * The constructor.
699 */
700 public DataHandlerDataSource(DataHandler dh) {
701 this.dataHandler = dh;
702 }
703
704 /**
705 * Returns an {@code InputStream} representing this object.
706 * @return the {@code InputStream}
707 */
708 public InputStream getInputStream() throws IOException {
709 return dataHandler.getInputStream();
710 }
711
712 /**
713 * Returns the {@code OutputStream} for this object.
714 * @return the {@code OutputStream}
715 */
716 public OutputStream getOutputStream() throws IOException {
717 return dataHandler.getOutputStream();
718 }
719
720 /**
721 * Returns the MIME type of the data represented by this object.
722 * @return the MIME type
723 */
724 public String getContentType() {
725 return dataHandler.getContentType();
726 }
727
728 /**
729 * Returns the name of this object.
730 * @return the name of this object
731 */
732 public String getName() {
733 return dataHandler.getName(); // what else would it be?
734 }
735 }
736
737 /*
738 * DataSourceDataContentHandler
739 *
740 * This is a <i>private</i> DataContentHandler that wraps the real
741 * DataContentHandler in the case where the DataHandler was instantiated
742 * with a DataSource.
743 */
744 class DataSourceDataContentHandler implements DataContentHandler {
745 private DataSource ds = null;
746 private DataFlavor transferFlavors[] = null;
747 private DataContentHandler dch = null;
748
749 /**
750 * The constructor.
751 */
752 public DataSourceDataContentHandler(DataContentHandler dch, DataSource ds) {
753 this.ds = ds;
754 this.dch = dch;
755 }
756
757 /**
758 * Return the DataFlavors for this {@code DataContentHandler}.
759 * @return the DataFlavors
760 */
761 public DataFlavor[] getTransferDataFlavors() {
762
763 if (transferFlavors == null) {
764 if (dch != null) { // is there a dch?
765 transferFlavors = dch.getTransferDataFlavors();
766 } else {
767 transferFlavors = new DataFlavor[1];
768 transferFlavors[0] =
769 new ActivationDataFlavor(ds.getContentType(),
770 ds.getContentType());
771 }
772 }
773 return transferFlavors;
774 }
775
776 /**
777 * Return the Transfer Data of type DataFlavor from InputStream.
778 * @param df the DataFlavor
779 * @param ds the DataSource
780 * @return the constructed Object
781 */
782 public Object getTransferData(DataFlavor df, DataSource ds) throws
783 UnsupportedFlavorException, IOException {
784
785 if (dch != null)
786 return dch.getTransferData(df, ds);
787 else if (df.equals(getTransferDataFlavors()[0])) // only have one now
788 return ds.getInputStream();
789 else
790 throw new UnsupportedFlavorException(df);
791 }
792
793 public Object getContent(DataSource ds) throws IOException {
794
795 if (dch != null)
796 return dch.getContent(ds);
797 else
798 return ds.getInputStream();
799 }
800
801 /**
802 * Write the object to the output stream.
803 */
804 public void writeTo(Object obj, String mimeType, OutputStream os)
805 throws IOException {
806 if (dch != null)
807 dch.writeTo(obj, mimeType, os);
808 else
809 throw new UnsupportedDataTypeException(
810 "no DCH for content type " + ds.getContentType());
811 }
812 }
813
814 /*
815 * ObjectDataContentHandler
816 *
817 * This is a <i>private</i> DataContentHandler that wraps the real
818 * DataContentHandler in the case where the DataHandler was instantiated
819 * with an object.
820 */
821 class ObjectDataContentHandler implements DataContentHandler {
822 private DataFlavor transferFlavors[] = null;
823 private Object obj;
824 private String mimeType;
825 private DataContentHandler dch = null;
826
827 /**
828 * The constructor.
829 */
830 public ObjectDataContentHandler(DataContentHandler dch,
831 Object obj, String mimeType) {
832 this.obj = obj;
833 this.mimeType = mimeType;
834 this.dch = dch;
835 }
836
837 /**
838 * Return the DataContentHandler for this object.
839 * Used only by the DataHandler class.
840 */
841 public DataContentHandler getDCH() {
842 return dch;
843 }
844
845 /**
846 * Return the DataFlavors for this {@code DataContentHandler}.
847 * @return the DataFlavors
848 */
849 public synchronized DataFlavor[] getTransferDataFlavors() {
850 if (transferFlavors == null) {
851 if (dch != null) {
852 transferFlavors = dch.getTransferDataFlavors();
853 } else {
854 transferFlavors = new DataFlavor[1];
855 transferFlavors[0] = new ActivationDataFlavor(obj.getClass(),
856 mimeType, mimeType);
857 }
858 }
859 return transferFlavors;
860 }
861
862 /**
863 * Return the Transfer Data of type DataFlavor from InputStream.
864 * @param df the DataFlavor
865 * @param ds the DataSource
866 * @return the constructed Object
867 */
868 public Object getTransferData(DataFlavor df, DataSource ds)
869 throws UnsupportedFlavorException, IOException {
870
871 if (dch != null)
872 return dch.getTransferData(df, ds);
873 else if (df.equals(getTransferDataFlavors()[0])) // only have one now
874 return obj;
875 else
876 throw new UnsupportedFlavorException(df);
877
878 }
879
880 public Object getContent(DataSource ds) {
881 return obj;
882 }
883
884 /**
885 * Write the object to the output stream.
886 */
887 public void writeTo(Object obj, String mimeType, OutputStream os)
888 throws IOException {
889 if (dch != null)
890 dch.writeTo(obj, mimeType, os);
891 else if (obj instanceof byte[])
892 os.write((byte[])obj);
893 else if (obj instanceof String) {
894 OutputStreamWriter osw = new OutputStreamWriter(os);
895 osw.write((String)obj);
896 osw.flush();
897 } else throw new UnsupportedDataTypeException(
898 "no object DCH for MIME type " + this.mimeType);
899 }
900 }