jdk8-mips64-public/jaxws: src/share/jaf_classes/javax/activation/DataHandler.java@9c07ef4934dd (annotated)

src/share/jaf_classes/javax/activation/DataHandler.java@9c07ef4934dd (annotated)

src/share/jaf_classes/javax/activation/DataHandler.java

Thu, 31 Aug 2017 15:18:52 +0800

author: aoqi
date: Thu, 31 Aug 2017 15:18:52 +0800
changeset 637: 9c07ef4934dd
parent 494: 2fcd3ddb57a6
parent 0: 373ffda63c9a
permissions: -rw-r--r--

merge

 /*
  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package javax.activation;
 import java.io.InputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
 import java.io.OutputStreamWriter;
 import java.net.URL;
 import java.awt.datatransfer.Transferable;
 import java.awt.datatransfer.DataFlavor;
 import java.awt.datatransfer.UnsupportedFlavorException;
 /**
  * The DataHandler class provides a consistent interface to data
  * available in many different sources and formats.
  * It manages simple stream to string conversions and related operations
  * using DataContentHandlers.
  * It provides access to commands that can operate on the data.
  * The commands are found using a CommandMap. <p>
  *
  * <b>DataHandler and the Transferable Interface</b><p>
  * DataHandler implements the Transferable interface so that data can
  * be used in AWT data transfer operations, such as cut and paste and
  * drag and drop. The implementation of the Transferable interface
  * relies on the availability of an installed DataContentHandler
  * object corresponding to the MIME type of the data represented in
  * the specific instance of the DataHandler.<p>
  *
  * <b>DataHandler and CommandMaps</b><p>
  * The DataHandler keeps track of the current CommandMap that it uses to
  * service requests for commands (<code>getCommand</code>,
  * <code>getAllCommands</code>, <code>getPreferredCommands</code>).
  * Each instance of a DataHandler may have a CommandMap associated with
  * it using the <code>setCommandMap</code> method.  If a CommandMap was
  * not set, DataHandler calls the <code>getDefaultCommandMap</code>
  * method in CommandMap and uses the value it returns. See
  * <i>CommandMap</i> for more information. <p>
  *
  * <b>DataHandler and URLs</b><p>
  * The current DataHandler implementation creates a private
  * instance of URLDataSource when it is constructed with a URL.
  *
  * @see javax.activation.CommandMap
  * @see javax.activation.DataContentHandler
  * @see javax.activation.DataSource
  * @see javax.activation.URLDataSource
  *
  * @since 1.6
  */
 public class DataHandler implements Transferable {
     // Use the datasource to indicate whether we were started via the
     // DataSource constructor or the object constructor.
     private DataSource dataSource = null;
     private DataSource objDataSource = null;
     // The Object and mimetype from the constructor (if passed in).
     // object remains null if it was instantiated with a
     // DataSource.
     private Object object = null;
     private String objectMimeType = null;
     // Keep track of the CommandMap
     private CommandMap currentCommandMap = null;
     // our transfer flavors
     private static final DataFlavor emptyFlavors[] = new DataFlavor[0];
     private DataFlavor transferFlavors[] = emptyFlavors;
     // our DataContentHandler
     private DataContentHandler dataContentHandler = null;
     private DataContentHandler factoryDCH = null;
     // our DataContentHandlerFactory
     private static DataContentHandlerFactory factory = null;
     private DataContentHandlerFactory oldFactory = null;
     // the short representation of the ContentType (sans params)
     private String shortType = null;
     /**
      * Create a <code>DataHandler</code> instance referencing the
      * specified DataSource.  The data exists in a byte stream form.
      * The DataSource will provide an InputStream to access the data.
      *
      * @param ds        the DataSource
      */
     public DataHandler(DataSource ds) {
         // save a reference to the incoming DS
         dataSource = ds;
         oldFactory = factory; // keep track of the factory
     }
     /**
      * Create a <code>DataHandler</code> instance representing an object
      * of this MIME type.  This constructor is
      * used when the application already has an in-memory representation
      * of the data in the form of a Java Object.
      *
      * @param obj       the Java Object
      * @param mimeType  the MIME type of the object
      */
     public DataHandler(Object obj, String mimeType) {
         object = obj;
         objectMimeType = mimeType;
         oldFactory = factory; // keep track of the factory
     }
     /**
      * Create a <code>DataHandler</code> instance referencing a URL.
      * The DataHandler internally creates a <code>URLDataSource</code>
      * instance to represent the URL.
      *
      * @param url       a URL object
      */
     public DataHandler(URL url) {
         dataSource = new URLDataSource(url);
         oldFactory = factory; // keep track of the factory
     }
     /**
      * Return the CommandMap for this instance of DataHandler.
      */
     private synchronized CommandMap getCommandMap() {
         if (currentCommandMap != null)
             return currentCommandMap;
         else
             return CommandMap.getDefaultCommandMap();
     }
     /**
      * Return the DataSource associated with this instance
      * of DataHandler.
      * <p>
      * For DataHandlers that have been instantiated with a DataSource,
      * this method returns the DataSource that was used to create the
      * DataHandler object. In other cases the DataHandler
      * constructs a DataSource from the data used to construct
      * the DataHandler. DataSources created for DataHandlers <b>not</b>
      * instantiated with a DataSource are cached for performance
      * reasons.
      *
      * @return  a valid DataSource object for this DataHandler
      */
     public DataSource getDataSource() {
         if (dataSource == null) {
             // create one on the fly
             if (objDataSource == null)
                 objDataSource = new DataHandlerDataSource(this);
             return objDataSource;
         }
         return dataSource;
     }
     /**
      * Return the name of the data object. If this DataHandler
      * was created with a DataSource, this method calls through
      * to the <code>DataSource.getName</code> method, otherwise it
      * returns <i>null</i>.
      *
      * @return  the name of the object
      */
     public String getName() {
         if (dataSource != null)
             return dataSource.getName();
         else
             return null;
     }
     /**
      * Return the MIME type of this object as retrieved from
      * the source object. Note that this is the <i>full</i>
      * type with parameters.
      *
      * @return  the MIME type
      */
     public String getContentType() {
         if (dataSource != null) // data source case
             return dataSource.getContentType();
         else
             return objectMimeType; // obj/type case
     }
     /**
      * Get the InputStream for this object. <p>
      *
      * For DataHandlers instantiated with a DataSource, the DataHandler
      * calls the <code>DataSource.getInputStream</code> method and
      * returns the result to the caller.
      * <p>
      * For DataHandlers instantiated with an Object, the DataHandler
      * first attempts to find a DataContentHandler for the Object. If
      * the DataHandler can not find a DataContentHandler for this MIME
      * type, it throws an UnsupportedDataTypeException.  If it is
      * successful, it creates a pipe and a thread.  The thread uses the
      * DataContentHandler's <code>writeTo</code> method to write the
      * stream data into one end of the pipe.  The other end of the pipe
      * is returned to the caller.  Because a thread is created to copy
      * the data, IOExceptions that may occur during the copy can not be
      * propagated back to the caller. The result is an empty stream.<p>
      *
      * @return  the InputStream representing this data
      * @exception IOException   if an I/O error occurs
      *
      * @see javax.activation.DataContentHandler#writeTo
      * @see javax.activation.UnsupportedDataTypeException
      */
     public InputStream getInputStream() throws IOException {
         InputStream ins = null;
         if (dataSource != null) {
             ins = dataSource.getInputStream();
         } else {
             DataContentHandler dch = getDataContentHandler();
             // we won't even try if we can't get a dch
             if (dch == null)
                 throw new UnsupportedDataTypeException(
                                 "no DCH for MIME type " + getBaseType());
             if (dch instanceof ObjectDataContentHandler) {
                 if (((ObjectDataContentHandler)dch).getDCH() == null)
                     throw new UnsupportedDataTypeException(
                                 "no object DCH for MIME type " + getBaseType());
             }
             // there is none but the default^^^^^^^^^^^^^^^^
             final DataContentHandler fdch = dch;
             // from bill s.
             // ce n'est pas une pipe!
             //
             // NOTE: This block of code needs to throw exceptions, but
             // can't because it is in another thread!!! ARG!
             //
             final PipedOutputStream pos = new PipedOutputStream();
             PipedInputStream pin = new PipedInputStream(pos);
             new Thread(
                        new Runnable() {
                 public void run() {
                     try {
                         fdch.writeTo(object, objectMimeType, pos);
                     } catch (IOException e) {
                     } finally {
                         try {
                             pos.close();
                         } catch (IOException ie) { }
                     }
                 }
             },
                       "DataHandler.getInputStream").start();
             ins = pin;
         }
         return ins;
     }
     /**
      * Write the data to an <code>OutputStream</code>.<p>
      *
      * If the DataHandler was created with a DataSource, writeTo
      * retrieves the InputStream and copies the bytes from the
      * InputStream to the OutputStream passed in.
      * <p>
      * If the DataHandler was created with an object, writeTo
      * retrieves the DataContentHandler for the object's type.
      * If the DataContentHandler was found, it calls the
      * <code>writeTo</code> method on the <code>DataContentHandler</code>.
      *
      * @param os        the OutputStream to write to
      * @exception IOException   if an I/O error occurs
      */
     public void writeTo(OutputStream os) throws IOException {
         // for the DataSource case
         if (dataSource != null) {
             InputStream is = null;
             byte data[] = new byte[8*1024];
             int bytes_read;
             is = dataSource.getInputStream();
             try {
                 while ((bytes_read = is.read(data)) > 0) {
                     os.write(data, 0, bytes_read);
                 }
             } finally {
                 is.close();
                 is = null;
             }
         } else { // for the Object case
             DataContentHandler dch = getDataContentHandler();
             dch.writeTo(object, objectMimeType, os);
         }
     }
     /**
      * Get an OutputStream for this DataHandler to allow overwriting
      * the underlying data.
      * If the DataHandler was created with a DataSource, the
      * DataSource's <code>getOutputStream</code> method is called.
      * Otherwise, <code>null</code> is returned.
      *
      * @return the OutputStream
      *
      * @see javax.activation.DataSource#getOutputStream
      * @see javax.activation.URLDataSource
      */
     public OutputStream getOutputStream() throws IOException {
         if (dataSource != null)
             return dataSource.getOutputStream();
         else
             return null;
     }
     /**
      * Return the DataFlavors in which this data is available. <p>
      *
      * Returns an array of DataFlavor objects indicating the flavors
      * the data can be provided in. The array is usually ordered
      * according to preference for providing the data, from most
      * richly descriptive to least richly descriptive.<p>
      *
      * The DataHandler attempts to find a DataContentHandler that
      * corresponds to the MIME type of the data. If one is located,
      * the DataHandler calls the DataContentHandler's
      * <code>getTransferDataFlavors</code> method. <p>
      *
      * If a DataContentHandler can <i>not</i> be located, and if the
      * DataHandler was created with a DataSource (or URL), one
      * DataFlavor is returned that represents this object's MIME type
      * and the <code>java.io.InputStream</code> class.  If the
      * DataHandler was created with an object and a MIME type,
      * getTransferDataFlavors returns one DataFlavor that represents
      * this object's MIME type and the object's class.
      *
      * @return  an array of data flavors in which this data can be transferred
      * @see javax.activation.DataContentHandler#getTransferDataFlavors
      */
     public synchronized DataFlavor[] getTransferDataFlavors() {
         if (factory != oldFactory) // if the factory has changed, clear cache
             transferFlavors = emptyFlavors;
         // if it's not set, set it...
         if (transferFlavors == emptyFlavors)
             transferFlavors = getDataContentHandler().getTransferDataFlavors();
         if (transferFlavors == emptyFlavors)
             return transferFlavors;
         else
             return transferFlavors.clone();
     }
     /**
      * Returns whether the specified data flavor is supported
      * for this object.<p>
      *
      * This method iterates through the DataFlavors returned from
      * <code>getTransferDataFlavors</code>, comparing each with
      * the specified flavor.
      *
      * @param flavor    the requested flavor for the data
      * @return          true if the data flavor is supported
      * @see javax.activation.DataHandler#getTransferDataFlavors
      */
     public boolean isDataFlavorSupported(DataFlavor flavor) {
         DataFlavor[] lFlavors = getTransferDataFlavors();
         for (int i = 0; i < lFlavors.length; i++) {
             if (lFlavors[i].equals(flavor))
                 return true;
         }
         return false;
     }
     /**
      * Returns an object that represents the data to be
      * transferred. The class of the object returned is defined by the
      * representation class of the data flavor.<p>
      *
      * <b>For DataHandler's created with DataSources or URLs:</b><p>
      *
      * The DataHandler attempts to locate a DataContentHandler
      * for this MIME type. If one is found, the passed in DataFlavor
      * and the type of the data are passed to its <code>getTransferData</code>
      * method. If the DataHandler fails to locate a DataContentHandler
      * and the flavor specifies this object's MIME type and the
      * <code>java.io.InputStream</code> class, this object's InputStream
      * is returned.
      * Otherwise it throws an UnsupportedFlavorException. <p>
      *
      * <b>For DataHandler's created with Objects:</b><p>
      *
      * The DataHandler attempts to locate a DataContentHandler
      * for this MIME type. If one is found, the passed in DataFlavor
      * and the type of the data are passed to its getTransferData
      * method. If the DataHandler fails to locate a DataContentHandler
      * and the flavor specifies this object's MIME type and its class,
      * this DataHandler's referenced object is returned.
      * Otherwise it throws an UnsupportedFlavorException.
      *
      * @param flavor    the requested flavor for the data
      * @return          the object
      * @exception UnsupportedFlavorException    if the data could not be
      *                  converted to the requested flavor
      * @exception IOException   if an I/O error occurs
      * @see javax.activation.ActivationDataFlavor
      */
     public Object getTransferData(DataFlavor flavor)
                                 throws UnsupportedFlavorException, IOException {
         return getDataContentHandler().getTransferData(flavor, dataSource);
     }
     /**
      * Set the CommandMap for use by this DataHandler.
      * Setting it to <code>null</code> causes the CommandMap to revert
      * to the CommandMap returned by the
      * <code>CommandMap.getDefaultCommandMap</code> method.
      * Changing the CommandMap, or setting it to <code>null</code>,
      * clears out any data cached from the previous CommandMap.
      *
      * @param commandMap        the CommandMap to use in this DataHandler
      *
      * @see javax.activation.CommandMap#setDefaultCommandMap
      */
     public synchronized void setCommandMap(CommandMap commandMap) {
         if (commandMap != currentCommandMap || commandMap == null) {
             // clear cached values...
             transferFlavors = emptyFlavors;
             dataContentHandler = null;
             currentCommandMap = commandMap;
         }
     }
     /**
      * Return the <i>preferred</i> commands for this type of data.
      * This method calls the <code>getPreferredCommands</code> method
      * in the CommandMap associated with this instance of DataHandler.
      * This method returns an array that represents a subset of
      * available commands. In cases where multiple commands for the
      * MIME type represented by this DataHandler are present, the
      * installed CommandMap chooses the appropriate commands.
      *
      * @return  the CommandInfo objects representing the preferred commands
      *
      * @see javax.activation.CommandMap#getPreferredCommands
      */
     public CommandInfo[] getPreferredCommands() {
         if (dataSource != null)
             return getCommandMap().getPreferredCommands(getBaseType(),
                                                         dataSource);
         else
             return getCommandMap().getPreferredCommands(getBaseType());
     }
     /**
      * Return all the commands for this type of data.
      * This method returns an array containing all commands
      * for the type of data represented by this DataHandler. The
      * MIME type for the underlying data represented by this DataHandler
      * is used to call through to the <code>getAllCommands</code> method
      * of the CommandMap associated with this DataHandler.
      *
      * @return  the CommandInfo objects representing all the commands
      *
      * @see javax.activation.CommandMap#getAllCommands
      */
     public CommandInfo[] getAllCommands() {
         if (dataSource != null)
             return getCommandMap().getAllCommands(getBaseType(), dataSource);
         else
             return getCommandMap().getAllCommands(getBaseType());
     }
     /**
      * Get the command <i>cmdName</i>. Use the search semantics as
      * defined by the CommandMap installed in this DataHandler. The
      * MIME type for the underlying data represented by this DataHandler
      * is used to call through to the <code>getCommand</code> method
      * of the CommandMap associated with this DataHandler.
      *
      * @param cmdName   the command name
      * @return  the CommandInfo corresponding to the command
      *
      * @see javax.activation.CommandMap#getCommand
      */
     public CommandInfo getCommand(String cmdName) {
         if (dataSource != null)
             return getCommandMap().getCommand(getBaseType(), cmdName,
                                                                 dataSource);
         else
             return getCommandMap().getCommand(getBaseType(), cmdName);
     }
     /**
      * Return the data in its preferred Object form. <p>
      *
      * If the DataHandler was instantiated with an object, return
      * the object. <p>
      *
      * If the DataHandler was instantiated with a DataSource,
      * this method uses a DataContentHandler to return the content
      * object for the data represented by this DataHandler. If no
      * <code>DataContentHandler</code> can be found for the
      * the type of this data, the DataHandler returns an
      * InputStream for the data.
      *
      * @return the content.
      * @exception IOException if an IOException occurs during
      *                              this operation.
      */
     public Object getContent() throws IOException {
         if (object != null)
             return object;
         else
             return getDataContentHandler().getContent(getDataSource());
     }
     /**
      * A convenience method that takes a CommandInfo object
      * and instantiates the corresponding command, usually
      * a JavaBean component.
      * <p>
      * This method calls the CommandInfo's <code>getCommandObject</code>
      * method with the <code>ClassLoader</code> used to load
      * the <code>javax.activation.DataHandler</code> class itself.
      *
      * @param cmdinfo   the CommandInfo corresponding to a command
      * @return  the instantiated command object
      */
     public Object getBean(CommandInfo cmdinfo) {
         Object bean = null;
         try {
             // make the bean
             ClassLoader cld = null;
             // First try the "application's" class loader.
             cld = SecuritySupport.getContextClassLoader();
             if (cld == null)
                 cld = this.getClass().getClassLoader();
             bean = cmdinfo.getCommandObject(this, cld);
         } catch (IOException e) {
         } catch (ClassNotFoundException e) { }
         return bean;
     }
     /**
      * Get the DataContentHandler for this DataHandler: <p>
      *
      * If a DataContentHandlerFactory is set, use it.
      * Otherwise look for an object to serve DCH in the
      * following order: <p>
      *
      * 1) if a factory is set, use it <p>
      * 2) if a CommandMap is set, use it <p>
      * 3) use the default CommandMap <p>
      *
      * In any case, wrap the real DataContentHandler with one of our own
      * to handle any missing cases, fill in defaults, and to ensure that
      * we always have a non-null DataContentHandler.
      *
      * @return  the requested DataContentHandler
      */
     private synchronized DataContentHandler getDataContentHandler() {
         // make sure the factory didn't change
         if (factory != oldFactory) {
             oldFactory = factory;
             factoryDCH = null;
             dataContentHandler = null;
             transferFlavors = emptyFlavors;
         }
         if (dataContentHandler != null)
             return dataContentHandler;
         String simpleMT = getBaseType();
         if (factoryDCH == null && factory != null)
             factoryDCH = factory.createDataContentHandler(simpleMT);
         if (factoryDCH != null)
             dataContentHandler = factoryDCH;
         if (dataContentHandler == null) {
             if (dataSource != null)
                 dataContentHandler = getCommandMap().
                                 createDataContentHandler(simpleMT, dataSource);
             else
                 dataContentHandler = getCommandMap().
                                 createDataContentHandler(simpleMT);
         }
         // getDataContentHandler always uses these 'wrapper' handlers
         // to make sure it returns SOMETHING meaningful...
         if (dataSource != null)
             dataContentHandler = new DataSourceDataContentHandler(
                                                       dataContentHandler,
                                                       dataSource);
         else
             dataContentHandler = new ObjectDataContentHandler(
                                                       dataContentHandler,
                                                       object,
                                                       objectMimeType);
         return dataContentHandler;
     }
     /**
      * Use the MimeType class to extract the MIME type/subtype,
      * ignoring the parameters.  The type is cached.
      */
     private synchronized String getBaseType() {
         if (shortType == null) {
             String ct = getContentType();
             try {
                 MimeType mt = new MimeType(ct);
                 shortType = mt.getBaseType();
             } catch (MimeTypeParseException e) {
                 shortType = ct;
             }
         }
         return shortType;
     }
     /**
      * Sets the DataContentHandlerFactory.  The DataContentHandlerFactory
      * is called first to find DataContentHandlers.
      * The DataContentHandlerFactory can only be set once.
      * <p>
      * If the DataContentHandlerFactory has already been set,
      * this method throws an Error.
      *
      * @param newFactory        the DataContentHandlerFactory
      * @exception Error if the factory has already been defined.
      *
      * @see javax.activation.DataContentHandlerFactory
      */
     public static synchronized void setDataContentHandlerFactory(
                                          DataContentHandlerFactory newFactory) {
         if (factory != null)
             throw new Error("DataContentHandlerFactory already defined");
         SecurityManager security = System.getSecurityManager();
         if (security != null) {
             try {
                 // if it's ok with the SecurityManager, it's ok with me...
                 security.checkSetFactory();
             } catch (SecurityException ex) {
                 // otherwise, we also allow it if this code and the
                 // factory come from the same class loader (e.g.,
                 // the JAF classes were loaded with the applet classes).
                 if (DataHandler.class.getClassLoader() !=
                         newFactory.getClass().getClassLoader())
                     throw ex;
             }
         }
         factory = newFactory;
     }
 }
 /**
  * The DataHanderDataSource class implements the
  * DataSource interface when the DataHandler is constructed
  * with an Object and a mimeType string.
  */
 class DataHandlerDataSource implements DataSource {
     DataHandler dataHandler = null;
     /**
      * The constructor.
      */
     public DataHandlerDataSource(DataHandler dh) {
         this.dataHandler = dh;
     }
     /**
      * Returns an <code>InputStream</code> representing this object.
      * @return  the <code>InputStream</code>
      */
     public InputStream getInputStream() throws IOException {
         return dataHandler.getInputStream();
     }
     /**
      * Returns the <code>OutputStream</code> for this object.
      * @return  the <code>OutputStream</code>
      */
     public OutputStream getOutputStream() throws IOException {
         return dataHandler.getOutputStream();
     }
     /**
      * Returns the MIME type of the data represented by this object.
      * @return  the MIME type
      */
     public String getContentType() {
         return dataHandler.getContentType();
     }
     /**
      * Returns the name of this object.
      * @return  the name of this object
      */
     public String getName() {
         return dataHandler.getName(); // what else would it be?
     }
 }
 /*
  * DataSourceDataContentHandler
  *
  * This is a <i>private</i> DataContentHandler that wraps the real
  * DataContentHandler in the case where the DataHandler was instantiated
  * with a DataSource.
  */
 class DataSourceDataContentHandler implements DataContentHandler {
     private DataSource ds = null;
     private DataFlavor transferFlavors[] = null;
     private DataContentHandler dch = null;
     /**
      * The constructor.
      */
     public DataSourceDataContentHandler(DataContentHandler dch, DataSource ds) {
         this.ds = ds;
         this.dch = dch;
     }
     /**
      * Return the DataFlavors for this <code>DataContentHandler</code>.
      * @return  the DataFlavors
      */
     public DataFlavor[] getTransferDataFlavors() {
         if (transferFlavors == null) {
             if (dch != null) { // is there a dch?
                 transferFlavors = dch.getTransferDataFlavors();
             } else {
                 transferFlavors = new DataFlavor[1];
                 transferFlavors[0] =
                     new ActivationDataFlavor(ds.getContentType(),
                                              ds.getContentType());
             }
         }
         return transferFlavors;
     }
     /**
      * Return the Transfer Data of type DataFlavor from InputStream.
      * @param df        the DataFlavor
      * @param ds        the DataSource
      * @return          the constructed Object
      */
     public Object getTransferData(DataFlavor df, DataSource ds) throws
                                 UnsupportedFlavorException, IOException {
         if (dch != null)
             return dch.getTransferData(df, ds);
         else if (df.equals(getTransferDataFlavors()[0])) // only have one now
             return ds.getInputStream();
         else
             throw new UnsupportedFlavorException(df);
     }
     public Object getContent(DataSource ds) throws IOException {
         if (dch != null)
             return dch.getContent(ds);
         else
             return ds.getInputStream();
     }
     /**
      * Write the object to the output stream.
      */
     public void writeTo(Object obj, String mimeType, OutputStream os)
                                                 throws IOException {
         if (dch != null)
             dch.writeTo(obj, mimeType, os);
         else
             throw new UnsupportedDataTypeException(
                         "no DCH for content type " + ds.getContentType());
     }
 }
 /*
  * ObjectDataContentHandler
  *
  * This is a <i>private</i> DataContentHandler that wraps the real
  * DataContentHandler in the case where the DataHandler was instantiated
  * with an object.
  */
 class ObjectDataContentHandler implements DataContentHandler {
     private DataFlavor transferFlavors[] = null;
     private Object obj;
     private String mimeType;
     private DataContentHandler dch = null;
     /**
      * The constructor.
      */
     public ObjectDataContentHandler(DataContentHandler dch,
                                     Object obj, String mimeType) {
         this.obj = obj;
         this.mimeType = mimeType;
         this.dch = dch;
     }
     /**
      * Return the DataContentHandler for this object.
      * Used only by the DataHandler class.
      */
     public DataContentHandler getDCH() {
         return dch;
     }
     /**
      * Return the DataFlavors for this <code>DataContentHandler</code>.
      * @return  the DataFlavors
      */
     public synchronized DataFlavor[] getTransferDataFlavors() {
         if (transferFlavors == null) {
             if (dch != null) {
                 transferFlavors = dch.getTransferDataFlavors();
             } else {
                 transferFlavors = new DataFlavor[1];
                 transferFlavors[0] = new ActivationDataFlavor(obj.getClass(),
                                              mimeType, mimeType);
             }
         }
         return transferFlavors;
     }
     /**
      * Return the Transfer Data of type DataFlavor from InputStream.
      * @param df        the DataFlavor
      * @param ds        the DataSource
      * @return          the constructed Object
      */
     public Object getTransferData(DataFlavor df, DataSource ds)
                                 throws UnsupportedFlavorException, IOException {
         if (dch != null)
             return dch.getTransferData(df, ds);
         else if (df.equals(getTransferDataFlavors()[0])) // only have one now
             return obj;
         else
             throw new UnsupportedFlavorException(df);
     }
     public Object getContent(DataSource ds) {
         return obj;
     }
     /**
      * Write the object to the output stream.
      */
     public void writeTo(Object obj, String mimeType, OutputStream os)
                                                 throws IOException {
         if (dch != null)
             dch.writeTo(obj, mimeType, os);
         else if (obj instanceof byte[])
             os.write((byte[])obj);
         else if (obj instanceof String) {
             OutputStreamWriter osw = new OutputStreamWriter(os);
             osw.write((String)obj);
             osw.flush();
         } else throw new UnsupportedDataTypeException(
                 "no object DCH for MIME type " + this.mimeType);
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaf_classes/javax/activation/DataHandler.java@9c07ef4934dd (annotated)

src/share/jaf_classes/javax/activation/DataHandler.java