DataHandler.java

/*
 * 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);
    }
}