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.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      *
 330      * @see javax.activation.DataSource#getOutputStream
 331      * @see javax.activation.URLDataSource
 332      */
 333     public OutputStream getOutputStream() throws IOException {
 334         if (dataSource != null)
 335             return dataSource.getOutputStream();
 336         else
 337             return null;
 338     }
 339 
 340     /**
 341      * Return the DataFlavors in which this data is available. <p>
 342      *
 343      * Returns an array of DataFlavor objects indicating the flavors
 344      * the data can be provided in. The array is usually ordered
 345      * according to preference for providing the data, from most
 346      * richly descriptive to least richly descriptive.<p>
 347      *
 348      * The DataHandler attempts to find a DataContentHandler that
 349      * corresponds to the MIME type of the data. If one is located,
 350      * the DataHandler calls the DataContentHandler's
 351      * {@code getTransferDataFlavors} method. <p>
 352      *
 353      * If a DataContentHandler can <i>not</i> be located, and if the
 354      * DataHandler was created with a DataSource (or URL), one
 355      * DataFlavor is returned that represents this object's MIME type
 356      * and the {@code java.io.InputStream} class.  If the
 357      * DataHandler was created with an object and a MIME type,
 358      * getTransferDataFlavors returns one DataFlavor that represents
 359      * this object's MIME type and the object's class.
 360      *
 361      * @return  an array of data flavors in which this data can be transferred
 362      * @see javax.activation.DataContentHandler#getTransferDataFlavors
 363      */
 364     public synchronized DataFlavor[] getTransferDataFlavors() {
 365         if (factory != oldFactory) // if the factory has changed, clear cache
 366             transferFlavors = emptyFlavors;
 367 
 368         // if it's not set, set it...
 369         if (transferFlavors == emptyFlavors)
 370             transferFlavors = getDataContentHandler().getTransferDataFlavors();
 371 
 372         if (transferFlavors == emptyFlavors)
 373             return transferFlavors;
 374         else
 375             return transferFlavors.clone();
 376 
 377     }
 378 
 379     /**
 380      * Returns whether the specified data flavor is supported
 381      * for this object.<p>
 382      *
 383      * This method iterates through the DataFlavors returned from
 384      * {@code getTransferDataFlavors}, comparing each with
 385      * the specified flavor.
 386      *
 387      * @param flavor    the requested flavor for the data
 388      * @return          true if the data flavor is supported
 389      * @see javax.activation.DataHandler#getTransferDataFlavors
 390      */
 391     public boolean isDataFlavorSupported(DataFlavor flavor) {
 392         DataFlavor[] lFlavors = getTransferDataFlavors();
 393 
 394         for (int i = 0; i < lFlavors.length; i++) {
 395             if (lFlavors[i].equals(flavor))
 396                 return true;
 397         }
 398         return false;
 399     }
 400 
 401     /**
 402      * Returns an object that represents the data to be
 403      * transferred. The class of the object returned is defined by the
 404      * representation class of the data flavor.<p>
 405      *
 406      * <b>For DataHandler's created with DataSources or URLs:</b><p>
 407      *
 408      * The DataHandler attempts to locate a DataContentHandler
 409      * for this MIME type. If one is found, the passed in DataFlavor
 410      * and the type of the data are passed to its {@code getTransferData}
 411      * method. If the DataHandler fails to locate a DataContentHandler
 412      * and the flavor specifies this object's MIME type and the
 413      * {@code java.io.InputStream} class, this object's InputStream
 414      * is returned.
 415      * Otherwise it throws an UnsupportedFlavorException. <p>
 416      *
 417      * <b>For DataHandler's created with Objects:</b><p>
 418      *
 419      * The DataHandler attempts to locate a DataContentHandler
 420      * for this MIME type. If one is found, the passed in DataFlavor
 421      * and the type of the data are passed to its getTransferData
 422      * method. If the DataHandler fails to locate a DataContentHandler
 423      * and the flavor specifies this object's MIME type and its class,
 424      * this DataHandler's referenced object is returned.
 425      * Otherwise it throws an UnsupportedFlavorException.
 426      *
 427      * @param flavor    the requested flavor for the data
 428      * @return          the object
 429      * @exception UnsupportedFlavorException    if the data could not be
 430      *                  converted to the requested flavor
 431      * @exception IOException   if an I/O error occurs
 432      * @see javax.activation.ActivationDataFlavor
 433      */
 434     public Object getTransferData(DataFlavor flavor)
 435                                 throws UnsupportedFlavorException, IOException {
 436         return getDataContentHandler().getTransferData(flavor, dataSource);
 437     }
 438 
 439     /**
 440      * Set the CommandMap for use by this DataHandler.
 441      * Setting it to {@code null} causes the CommandMap to revert
 442      * to the CommandMap returned by the
 443      * {@code CommandMap.getDefaultCommandMap} method.
 444      * Changing the CommandMap, or setting it to {@code null},
 445      * clears out any data cached from the previous CommandMap.
 446      *
 447      * @param commandMap        the CommandMap to use in this DataHandler
 448      *
 449      * @see javax.activation.CommandMap#setDefaultCommandMap
 450      */
 451     public synchronized void setCommandMap(CommandMap commandMap) {
 452         if (commandMap != currentCommandMap || commandMap == null) {
 453             // clear cached values...
 454             transferFlavors = emptyFlavors;
 455             dataContentHandler = null;
 456 
 457             currentCommandMap = commandMap;
 458         }
 459     }
 460 
 461     /**
 462      * Return the <i>preferred</i> commands for this type of data.
 463      * This method calls the {@code getPreferredCommands} method
 464      * in the CommandMap associated with this instance of DataHandler.
 465      * This method returns an array that represents a subset of
 466      * available commands. In cases where multiple commands for the
 467      * MIME type represented by this DataHandler are present, the
 468      * installed CommandMap chooses the appropriate commands.
 469      *
 470      * @return  the CommandInfo objects representing the preferred commands
 471      *
 472      * @see javax.activation.CommandMap#getPreferredCommands
 473      */
 474     public CommandInfo[] getPreferredCommands() {
 475         if (dataSource != null)
 476             return getCommandMap().getPreferredCommands(getBaseType(),
 477                                                         dataSource);
 478         else
 479             return getCommandMap().getPreferredCommands(getBaseType());
 480     }
 481 
 482     /**
 483      * Return all the commands for this type of data.
 484      * This method returns an array containing all commands
 485      * for the type of data represented by this DataHandler. The
 486      * MIME type for the underlying data represented by this DataHandler
 487      * is used to call through to the {@code getAllCommands} method
 488      * of the CommandMap associated with this DataHandler.
 489      *
 490      * @return  the CommandInfo objects representing all the commands
 491      *
 492      * @see javax.activation.CommandMap#getAllCommands
 493      */
 494     public CommandInfo[] getAllCommands() {
 495         if (dataSource != null)
 496             return getCommandMap().getAllCommands(getBaseType(), dataSource);
 497         else
 498             return getCommandMap().getAllCommands(getBaseType());
 499     }
 500 
 501     /**
 502      * Get the command <i>cmdName</i>. Use the search semantics as
 503      * defined by the CommandMap installed in this DataHandler. The
 504      * MIME type for the underlying data represented by this DataHandler
 505      * is used to call through to the {@code getCommand} method
 506      * of the CommandMap associated with this DataHandler.
 507      *
 508      * @param cmdName   the command name
 509      * @return  the CommandInfo corresponding to the command
 510      *
 511      * @see javax.activation.CommandMap#getCommand
 512      */
 513     public CommandInfo getCommand(String cmdName) {
 514         if (dataSource != null)
 515             return getCommandMap().getCommand(getBaseType(), cmdName,
 516                                                                 dataSource);
 517         else
 518             return getCommandMap().getCommand(getBaseType(), cmdName);
 519     }
 520 
 521     /**
 522      * Return the data in its preferred Object form. <p>
 523      *
 524      * If the DataHandler was instantiated with an object, return
 525      * the object. <p>
 526      *
 527      * If the DataHandler was instantiated with a DataSource,
 528      * this method uses a DataContentHandler to return the content
 529      * object for the data represented by this DataHandler. If no
 530      * {@code DataContentHandler} can be found for the
 531      * the type of this data, the DataHandler returns an
 532      * InputStream for the data.
 533      *
 534      * @return the content.
 535      * @exception IOException if an IOException occurs during
 536      *                              this operation.
 537      */
 538     public Object getContent() throws IOException {
 539         if (object != null)
 540             return object;
 541         else
 542             return getDataContentHandler().getContent(getDataSource());
 543     }
 544 
 545     /**
 546      * A convenience method that takes a CommandInfo object
 547      * and instantiates the corresponding command, usually
 548      * a JavaBean component.
 549      * <p>
 550      * This method calls the CommandInfo's {@code getCommandObject}
 551      * method with the {@code ClassLoader} used to load
 552      * the {@code javax.activation.DataHandler} class itself.
 553      *
 554      * @param cmdinfo   the CommandInfo corresponding to a command
 555      * @return  the instantiated command object
 556      */
 557     public Object getBean(CommandInfo cmdinfo) {
 558         Object bean = null;
 559 
 560         try {
 561             // make the bean
 562             ClassLoader cld = null;
 563             // First try the "application's" class loader.
 564             cld = SecuritySupport.getContextClassLoader();
 565             if (cld == null)
 566                 cld = this.getClass().getClassLoader();
 567             bean = cmdinfo.getCommandObject(this, cld);
 568         } catch (IOException e) {
 569         } catch (ClassNotFoundException e) { }
 570 
 571         return bean;
 572     }
 573 
 574     /**
 575      * Get the DataContentHandler for this DataHandler: <p>
 576      *
 577      * If a DataContentHandlerFactory is set, use it.
 578      * Otherwise look for an object to serve DCH in the
 579      * following order: <p>
 580      *
 581      * 1) if a factory is set, use it <p>
 582      * 2) if a CommandMap is set, use it <p>
 583      * 3) use the default CommandMap <p>
 584      *
 585      * In any case, wrap the real DataContentHandler with one of our own
 586      * to handle any missing cases, fill in defaults, and to ensure that
 587      * we always have a non-null DataContentHandler.
 588      *
 589      * @return  the requested DataContentHandler
 590      */
 591     private synchronized DataContentHandler getDataContentHandler() {
 592 
 593         // make sure the factory didn't change
 594         if (factory != oldFactory) {
 595             oldFactory = factory;
 596             factoryDCH = null;
 597             dataContentHandler = null;
 598             transferFlavors = emptyFlavors;
 599         }
 600 
 601         if (dataContentHandler != null)
 602             return dataContentHandler;
 603 
 604         String simpleMT = getBaseType();
 605 
 606         if (factoryDCH == null && factory != null)
 607             factoryDCH = factory.createDataContentHandler(simpleMT);
 608 
 609         if (factoryDCH != null)
 610             dataContentHandler = factoryDCH;
 611 
 612         if (dataContentHandler == null) {
 613             if (dataSource != null)
 614                 dataContentHandler = getCommandMap().
 615                                 createDataContentHandler(simpleMT, dataSource);
 616             else
 617                 dataContentHandler = getCommandMap().
 618                                 createDataContentHandler(simpleMT);
 619         }
 620 
 621         // getDataContentHandler always uses these 'wrapper' handlers
 622         // to make sure it returns SOMETHING meaningful...
 623         if (dataSource != null)
 624             dataContentHandler = new DataSourceDataContentHandler(
 625                                                       dataContentHandler,
 626                                                       dataSource);
 627         else
 628             dataContentHandler = new ObjectDataContentHandler(
 629                                                       dataContentHandler,
 630                                                       object,
 631                                                       objectMimeType);
 632         return dataContentHandler;
 633     }
 634 
 635     /**
 636      * Use the MimeType class to extract the MIME type/subtype,
 637      * ignoring the parameters.  The type is cached.
 638      */
 639     private synchronized String getBaseType() {
 640         if (shortType == null) {
 641             String ct = getContentType();
 642             try {
 643                 MimeType mt = new MimeType(ct);
 644                 shortType = mt.getBaseType();
 645             } catch (MimeTypeParseException e) {
 646                 shortType = ct;
 647             }
 648         }
 649         return shortType;
 650     }
 651 
 652     /**
 653      * Sets the DataContentHandlerFactory.  The DataContentHandlerFactory
 654      * is called first to find DataContentHandlers.
 655      * The DataContentHandlerFactory can only be set once.
 656      * <p>
 657      * If the DataContentHandlerFactory has already been set,
 658      * this method throws an Error.
 659      *
 660      * @param newFactory        the DataContentHandlerFactory
 661      * @exception Error if the factory has already been defined.
 662      *
 663      * @see javax.activation.DataContentHandlerFactory
 664      */
 665     public static synchronized void setDataContentHandlerFactory(
 666                                          DataContentHandlerFactory newFactory) {
 667         if (factory != null)
 668             throw new Error("DataContentHandlerFactory already defined");
 669 
 670         SecurityManager security = System.getSecurityManager();
 671         if (security != null) {
 672             try {
 673                 // if it's ok with the SecurityManager, it's ok with me...
 674                 security.checkSetFactory();
 675             } catch (SecurityException ex) {
 676                 // otherwise, we also allow it if this code and the
 677                 // factory come from the same class loader (e.g.,
 678                 // the JAF classes were loaded with the applet classes).
 679                 if (DataHandler.class.getClassLoader() !=
 680                         newFactory.getClass().getClassLoader())
 681                     throw ex;
 682             }
 683         }
 684         factory = newFactory;
 685     }
 686 }
 687 
 688 /**
 689  * The DataHanderDataSource class implements the
 690  * DataSource interface when the DataHandler is constructed
 691  * with an Object and a mimeType string.
 692  */
 693 class DataHandlerDataSource implements DataSource {
 694     DataHandler dataHandler = null;
 695 
 696     /**
 697      * The constructor.
 698      */
 699     public DataHandlerDataSource(DataHandler dh) {
 700         this.dataHandler = dh;
 701     }
 702 
 703     /**
 704      * Returns an {@code InputStream} representing this object.
 705      * @return  the {@code InputStream}
 706      */
 707     public InputStream getInputStream() throws IOException {
 708         return dataHandler.getInputStream();
 709     }
 710 
 711     /**
 712      * Returns the {@code OutputStream} for this object.
 713      * @return  the {@code OutputStream}
 714      */
 715     public OutputStream getOutputStream() throws IOException {
 716         return dataHandler.getOutputStream();
 717     }
 718 
 719     /**
 720      * Returns the MIME type of the data represented by this object.
 721      * @return  the MIME type
 722      */
 723     public String getContentType() {
 724         return dataHandler.getContentType();
 725     }
 726 
 727     /**
 728      * Returns the name of this object.
 729      * @return  the name of this object
 730      */
 731     public String getName() {
 732         return dataHandler.getName(); // what else would it be?
 733     }
 734 }
 735 
 736 /*
 737  * DataSourceDataContentHandler
 738  *
 739  * This is a <i>private</i> DataContentHandler that wraps the real
 740  * DataContentHandler in the case where the DataHandler was instantiated
 741  * with a DataSource.
 742  */
 743 class DataSourceDataContentHandler implements DataContentHandler {
 744     private DataSource ds = null;
 745     private DataFlavor transferFlavors[] = null;
 746     private DataContentHandler dch = null;
 747 
 748     /**
 749      * The constructor.
 750      */
 751     public DataSourceDataContentHandler(DataContentHandler dch, DataSource ds) {
 752         this.ds = ds;
 753         this.dch = dch;
 754     }
 755 
 756     /**
 757      * Return the DataFlavors for this {@code DataContentHandler}.
 758      * @return  the DataFlavors
 759      */
 760     public DataFlavor[] getTransferDataFlavors() {
 761 
 762         if (transferFlavors == null) {
 763             if (dch != null) { // is there a dch?
 764                 transferFlavors = dch.getTransferDataFlavors();
 765             } else {
 766                 transferFlavors = new DataFlavor[1];
 767                 transferFlavors[0] =
 768                     new ActivationDataFlavor(ds.getContentType(),
 769                                              ds.getContentType());
 770             }
 771         }
 772         return transferFlavors;
 773     }
 774 
 775     /**
 776      * Return the Transfer Data of type DataFlavor from InputStream.
 777      * @param df        the DataFlavor
 778      * @param ds        the DataSource
 779      * @return          the constructed Object
 780      */
 781     public Object getTransferData(DataFlavor df, DataSource ds) throws
 782                                 UnsupportedFlavorException, IOException {
 783 
 784         if (dch != null)
 785             return dch.getTransferData(df, ds);
 786         else if (df.equals(getTransferDataFlavors()[0])) // only have one now
 787             return ds.getInputStream();
 788         else
 789             throw new UnsupportedFlavorException(df);
 790     }
 791 
 792     public Object getContent(DataSource ds) throws IOException {
 793 
 794         if (dch != null)
 795             return dch.getContent(ds);
 796         else
 797             return ds.getInputStream();
 798     }
 799 
 800     /**
 801      * Write the object to the output stream.
 802      */
 803     public void writeTo(Object obj, String mimeType, OutputStream os)
 804                                                 throws IOException {
 805         if (dch != null)
 806             dch.writeTo(obj, mimeType, os);
 807         else
 808             throw new UnsupportedDataTypeException(
 809                         "no DCH for content type " + ds.getContentType());
 810     }
 811 }
 812 
 813 /*
 814  * ObjectDataContentHandler
 815  *
 816  * This is a <i>private</i> DataContentHandler that wraps the real
 817  * DataContentHandler in the case where the DataHandler was instantiated
 818  * with an object.
 819  */
 820 class ObjectDataContentHandler implements DataContentHandler {
 821     private DataFlavor transferFlavors[] = null;
 822     private Object obj;
 823     private String mimeType;
 824     private DataContentHandler dch = null;
 825 
 826     /**
 827      * The constructor.
 828      */
 829     public ObjectDataContentHandler(DataContentHandler dch,
 830                                     Object obj, String mimeType) {
 831         this.obj = obj;
 832         this.mimeType = mimeType;
 833         this.dch = dch;
 834     }
 835 
 836     /**
 837      * Return the DataContentHandler for this object.
 838      * Used only by the DataHandler class.
 839      */
 840     public DataContentHandler getDCH() {
 841         return dch;
 842     }
 843 
 844     /**
 845      * Return the DataFlavors for this {@code DataContentHandler}.
 846      * @return  the DataFlavors
 847      */
 848     public synchronized DataFlavor[] getTransferDataFlavors() {
 849         if (transferFlavors == null) {
 850             if (dch != null) {
 851                 transferFlavors = dch.getTransferDataFlavors();
 852             } else {
 853                 transferFlavors = new DataFlavor[1];
 854                 transferFlavors[0] = new ActivationDataFlavor(obj.getClass(),
 855                                              mimeType, mimeType);
 856             }
 857         }
 858         return transferFlavors;
 859     }
 860 
 861     /**
 862      * Return the Transfer Data of type DataFlavor from InputStream.
 863      * @param df        the DataFlavor
 864      * @param ds        the DataSource
 865      * @return          the constructed Object
 866      */
 867     public Object getTransferData(DataFlavor df, DataSource ds)
 868                                 throws UnsupportedFlavorException, IOException {
 869 
 870         if (dch != null)
 871             return dch.getTransferData(df, ds);
 872         else if (df.equals(getTransferDataFlavors()[0])) // only have one now
 873             return obj;
 874         else
 875             throw new UnsupportedFlavorException(df);
 876 
 877     }
 878 
 879     public Object getContent(DataSource ds) {
 880         return obj;
 881     }
 882 
 883     /**
 884      * Write the object to the output stream.
 885      */
 886     public void writeTo(Object obj, String mimeType, OutputStream os)
 887                                                 throws IOException {
 888         if (dch != null)
 889             dch.writeTo(obj, mimeType, os);
 890         else if (obj instanceof byte[])
 891             os.write((byte[])obj);
 892         else if (obj instanceof String) {
 893             OutputStreamWriter osw = new OutputStreamWriter(os);
 894             osw.write((String)obj);
 895             osw.flush();
 896         } else throw new UnsupportedDataTypeException(
 897                 "no object DCH for MIME type " + this.mimeType);
 898     }
 899 }
--- EOF ---