public DataHandler(DataSource ds) 
{
        // save a reference to the incoming DS
        dataSource = ds;
        oldFactory = factory; // keep track of the factory
}

Create a DataHandler instance referencing the specified DataSource. The data exists in a byte stream form. The DataSource will provide an InputStream to access the data.

Parameters:

ds - the DataSource

 public DataHandler(URL url) 
{
        dataSource = new URLDataSource(url);
        oldFactory = factory; // keep track of the factory
}

Create a DataHandler instance referencing a URL. The DataHandler internally creates a URLDataSource instance to represent the URL.

Parameters:

url - a URL object

 public DataHandler(Object obj,
    String mimeType) 
{
        object = obj;
        objectMimeType = mimeType;
        oldFactory = factory; // keep track of the factory
}

Create a DataHandler 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.

Parameters:

obj - the Java Object

mimeType - the MIME type of the object

 public CommandInfo[] getAllCommands() 
{
        if (dataSource != null)
            return getCommandMap().getAllCommands(getBaseType(), dataSource);
        else
            return getCommandMap().getAllCommands(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 getAllCommands method of the CommandMap associated with this DataHandler.

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

A convenience method that takes a CommandInfo object and instantiates the corresponding command, usually a JavaBean component.

This method calls the CommandInfo's getCommandObject method with the ClassLoader used to load the javax.activation.DataHandler class itself.

 public CommandInfo getCommand(String cmdName) 
{
        if (dataSource != null)
            return getCommandMap().getCommand(getBaseType(), cmdName,
                                                                dataSource);
        else
            return getCommandMap().getCommand(getBaseType(), cmdName);
}

Get the command cmdName. 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 getCommand method of the CommandMap associated with this DataHandler.

 public Object getContent() throws IOException 
{
        if (object != null)
            return object;
        else
            return getDataContentHandler().getContent(getDataSource());
}

Return the data in its preferred Object form.

If the DataHandler was instantiated with an object, return the object.

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 DataContentHandler can be found for the the type of this data, the DataHandler returns an InputStream for the data.

 public String getContentType() 
{
        if (dataSource != null) // data source case
            return dataSource.getContentType();
        else
            return objectMimeType; // obj/type case
}

Return the MIME type of this object as retrieved from the source object. Note that this is the full type with parameters.

 public DataSource getDataSource() 
{
        if (dataSource == null) {
            // create one on the fly
            if (objDataSource == null)
                objDataSource = new DataHandlerDataSource(this);
            return objDataSource;
        }
        return dataSource;
}

Return the DataSource associated with this instance of DataHandler.

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 not instantiated with a DataSource are cached for performance reasons.

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

Get the InputStream for this object.

For DataHandlers instantiated with a DataSource, the DataHandler calls the DataSource.getInputStream method and returns the result to the caller.

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 writeTo 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.

 public String getName() 
{
        if (dataSource != null)
            return dataSource.getName();
        else
            return null;
}

Return the name of the data object. If this DataHandler was created with a DataSource, this method calls through to the DataSource.getName method, otherwise it returns null.

 public OutputStream getOutputStream() throws IOException 
{
        if (dataSource != null)
            return dataSource.getOutputStream();
        else
            return null;
}

Get an OutputStream for this DataHandler to allow overwriting the underlying data. If the DataHandler was created with a DataSource, the DataSource's getOutputStream method is called. Otherwise, null is returned.

 public CommandInfo[] getPreferredCommands() 
{
        if (dataSource != null)
            return getCommandMap().getPreferredCommands(getBaseType(),
                                                        dataSource);
        else
            return getCommandMap().getPreferredCommands(getBaseType());
}

Return the preferred commands for this type of data. This method calls the getPreferredCommands 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.

 public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException 
{
        return getDataContentHandler().getTransferData(flavor, dataSource);
}

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.

For DataHandler's created with DataSources or URLs:

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 the java.io.InputStream class, this object's InputStream is returned. Otherwise it throws an UnsupportedFlavorException.

For DataHandler's created with Objects:

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.

 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();
        return transferFlavors;
}

Return the DataFlavors in which this data is available.

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.

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 getTransferDataFlavors method.

If a DataContentHandler can not 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 java.io.InputStream 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.

 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 whether the specified data flavor is supported for this object.

This method iterates through the DataFlavors returned from getTransferDataFlavors, comparing each with the specified flavor.

 public synchronized  void setCommandMap(CommandMap commandMap) 
{
        if (commandMap != currentCommandMap || commandMap == null) {
            // clear cached values...
            transferFlavors = emptyFlavors;
            dataContentHandler = null;
            currentCommandMap = commandMap;
        }
}

Set the CommandMap for use by this DataHandler. Setting it to null causes the CommandMap to revert to the CommandMap returned by the CommandMap.getDefaultCommandMap method. Changing the CommandMap, or setting it to null, clears out any data cached from the previous CommandMap.

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

Sets the DataContentHandlerFactory. The DataContentHandlerFactory is called first to find DataContentHandlers. The DataContentHandlerFactory can only be set once.

If the DataContentHandlerFactory has already been set, this method throws an Error.

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

Write the data to an OutputStream.

If the DataHandler was created with a DataSource, writeTo retrieves the InputStream and copies the bytes from the InputStream to the OutputStream passed in.

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 writeTo method on the DataContentHandler.