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 }
--- EOF ---