< prev index next >

src/java.desktop/share/classes/javax/imageio/ImageIO.java

Print this page

        

@@ -54,11 +54,11 @@
 import sun.awt.AppContext;
 import sun.security.action.GetPropertyAction;
 
 /**
  * A class containing static convenience methods for locating
- * <code>ImageReader</code>s and <code>ImageWriter</code>s, and
+ * {@code ImageReader}s and {@code ImageWriter}s, and
  * performing simple encoding and decoding.
  *
  */
 public final class ImageIO {
 

@@ -72,28 +72,28 @@
 
     /**
      * Scans for plug-ins on the application class path,
      * loads their service provider classes, and registers a service
      * provider instance for each one found with the
-     * <code>IIORegistry</code>.
+     * {@code IIORegistry}.
      *
      * <p>This method is needed because the application class path can
      * theoretically change, or additional plug-ins may become available.
      * Rather than re-scanning the classpath on every invocation of the
      * API, the class path is scanned automatically only on the first
      * invocation. Clients can call this method to prompt a re-scan.
      * Thus this method need only be invoked by sophisticated applications
      * which dynamically make new plug-ins available at runtime.
      *
-     * <p> The <code>getResources</code> method of the context
-     * <code>ClassLoader</code> is used locate JAR files containing
+     * <p> The {@code getResources} method of the context
+     * {@code ClassLoader} is used locate JAR files containing
      * files named
-     * <code>META-INF/services/javax.imageio.spi.</code><i>classname</i>,
-     * where <i>classname</i> is one of <code>ImageReaderSpi</code>,
-     * <code>ImageWriterSpi</code>, <code>ImageTranscoderSpi</code>,
-     * <code>ImageInputStreamSpi</code>, or
-     * <code>ImageOutputStreamSpi</code>, along the application class
+     * {@code META-INF/services/javax.imageio.spi.}<i>classname</i>,
+     * where <i>classname</i> is one of {@code ImageReaderSpi},
+     * {@code ImageWriterSpi}, {@code ImageTranscoderSpi},
+     * {@code ImageInputStreamSpi}, or
+     * {@code ImageOutputStreamSpi}, along the application class
      * path.
      *
      * <p> The contents of the located files indicate the names of
      * actual implementation classes which implement the
      * aforementioned service provider interfaces; the default class

@@ -112,12 +112,12 @@
 
     // ImageInputStreams
 
     /**
      * A class to hold information about caching.  Each
-     * <code>ThreadGroup</code> will have its own copy
-     * via the <code>AppContext</code> mechanism.
+     * {@code ThreadGroup} will have its own copy
+     * via the {@code AppContext} mechanism.
      */
     static class CacheInfo {
         boolean useCache = true;
         File cacheDirectory = null;
         Boolean hasPermission = null;

@@ -148,12 +148,12 @@
             this.hasPermission = hasPermission;
         }
     }
 
     /**
-     * Returns the <code>CacheInfo</code> object associated with this
-     * <code>ThreadGroup</code>.
+     * Returns the {@code CacheInfo} object associated with this
+     * {@code ThreadGroup}.
      */
     private static synchronized CacheInfo getCacheInfo() {
         AppContext context = AppContext.getAppContext();
         CacheInfo info = (CacheInfo)context.get(CacheInfo.class);
         if (info == null) {

@@ -172,11 +172,11 @@
         return AccessController.doPrivileged(a);
     }
 
     /**
      * Determines whether the caller has write access to the cache
-     * directory, stores the result in the <code>CacheInfo</code> object,
+     * directory, stores the result in the {@code CacheInfo} object,
      * and returns the decision.  This method helps to prevent mysterious
      * SecurityExceptions to be thrown when this convenience class is used
      * in an applet, for example.
      */
     private static boolean hasCachePermission() {

@@ -223,66 +223,66 @@
         }
     }
 
     /**
      * Sets a flag indicating whether a disk-based cache file should
-     * be used when creating <code>ImageInputStream</code>s and
-     * <code>ImageOutputStream</code>s.
+     * be used when creating {@code ImageInputStream}s and
+     * {@code ImageOutputStream}s.
      *
-     * <p> When reading from a standard <code>InputStream</code>, it
+     * <p> When reading from a standard {@code InputStream}, it
      * may be necessary to save previously read information in a cache
      * since the underlying stream does not allow data to be re-read.
      * Similarly, when writing to a standard
-     * <code>OutputStream</code>, a cache may be used to allow a
+     * {@code OutputStream}, a cache may be used to allow a
      * previously written value to be changed before flushing it to
      * the final destination.
      *
      * <p> The cache may reside in main memory or on disk.  Setting
-     * this flag to <code>false</code> disallows the use of disk for
+     * this flag to {@code false} disallows the use of disk for
      * future streams, which may be advantageous when working with
      * small images, as the overhead of creating and destroying files
      * is removed.
      *
-     * <p> On startup, the value is set to <code>true</code>.
+     * <p> On startup, the value is set to {@code true}.
      *
-     * @param useCache a <code>boolean</code> indicating whether a
+     * @param useCache a {@code boolean} indicating whether a
      * cache file should be used, in cases where it is optional.
      *
      * @see #getUseCache
      */
     public static void setUseCache(boolean useCache) {
         getCacheInfo().setUseCache(useCache);
     }
 
     /**
-     * Returns the current value set by <code>setUseCache</code>, or
-     * <code>true</code> if no explicit setting has been made.
+     * Returns the current value set by {@code setUseCache}, or
+     * {@code true} if no explicit setting has been made.
      *
      * @return true if a disk-based cache may be used for
-     * <code>ImageInputStream</code>s and
-     * <code>ImageOutputStream</code>s.
+     * {@code ImageInputStream}s and
+     * {@code ImageOutputStream}s.
      *
      * @see #setUseCache
      */
     public static boolean getUseCache() {
         return getCacheInfo().getUseCache();
     }
 
     /**
      * Sets the directory where cache files are to be created.  A
-     * value of <code>null</code> indicates that the system-dependent
+     * value of {@code null} indicates that the system-dependent
      * default temporary-file directory is to be used.  If
-     * <code>getUseCache</code> returns false, this value is ignored.
+     * {@code getUseCache} returns false, this value is ignored.
      *
-     * @param cacheDirectory a <code>File</code> specifying a directory.
+     * @param cacheDirectory a {@code File} specifying a directory.
      *
      * @see File#createTempFile(String, String, File)
      *
      * @exception SecurityException if the security manager denies
      * access to the directory.
-     * @exception IllegalArgumentException if <code>cacheDir</code> is
-     * non-<code>null</code> but is not a directory.
+     * @exception IllegalArgumentException if {@code cacheDir} is
+     * non-{@code null} but is not a directory.
      *
      * @see #getCacheDirectory
      */
     public static void setCacheDirectory(File cacheDirectory) {
         if ((cacheDirectory != null) && !(cacheDirectory.isDirectory())) {

@@ -292,44 +292,44 @@
         getCacheInfo().setHasPermission(null);
     }
 
     /**
      * Returns the current value set by
-     * <code>setCacheDirectory</code>, or <code>null</code> if no
+     * {@code setCacheDirectory}, or {@code null} if no
      * explicit setting has been made.
      *
-     * @return a <code>File</code> indicating the directory where
-     * cache files will be created, or <code>null</code> to indicate
+     * @return a {@code File} indicating the directory where
+     * cache files will be created, or {@code null} to indicate
      * the system-dependent default temporary-file directory.
      *
      * @see #setCacheDirectory
      */
     public static File getCacheDirectory() {
         return getCacheInfo().getCacheDirectory();
     }
 
     /**
-     * Returns an <code>ImageInputStream</code> that will take its
-     * input from the given <code>Object</code>.  The set of
-     * <code>ImageInputStreamSpi</code>s registered with the
-     * <code>IIORegistry</code> class is queried and the first one
+     * Returns an {@code ImageInputStream} that will take its
+     * input from the given {@code Object}.  The set of
+     * {@code ImageInputStreamSpi}s registered with the
+     * {@code IIORegistry} class is queried and the first one
      * that is able to take input from the supplied object is used to
-     * create the returned <code>ImageInputStream</code>.  If no
-     * suitable <code>ImageInputStreamSpi</code> exists,
-     * <code>null</code> is returned.
+     * create the returned {@code ImageInputStream}.  If no
+     * suitable {@code ImageInputStreamSpi} exists,
+     * {@code null} is returned.
      *
-     * <p> The current cache settings from <code>getUseCache</code>and
-     * <code>getCacheDirectory</code> will be used to control caching.
+     * <p> The current cache settings from {@code getUseCache} and
+     * {@code getCacheDirectory} will be used to control caching.
      *
-     * @param input an <code>Object</code> to be used as an input
-     * source, such as a <code>File</code>, readable
-     * <code>RandomAccessFile</code>, or <code>InputStream</code>.
+     * @param input an {@code Object} to be used as an input
+     * source, such as a {@code File}, readable
+     * {@code RandomAccessFile}, or {@code InputStream}.
      *
-     * @return an <code>ImageInputStream</code>, or <code>null</code>.
+     * @return an {@code ImageInputStream}, or {@code null}.
      *
-     * @exception IllegalArgumentException if <code>input</code>
-     * is <code>null</code>.
+     * @exception IllegalArgumentException if {@code input}
+     * is {@code null}.
      * @exception IOException if a cache file is needed but cannot be
      * created.
      *
      * @see javax.imageio.spi.ImageInputStreamSpi
      */

@@ -367,31 +367,31 @@
     }
 
     // ImageOutputStreams
 
     /**
-     * Returns an <code>ImageOutputStream</code> that will send its
-     * output to the given <code>Object</code>.  The set of
-     * <code>ImageOutputStreamSpi</code>s registered with the
-     * <code>IIORegistry</code> class is queried and the first one
+     * Returns an {@code ImageOutputStream} that will send its
+     * output to the given {@code Object}.  The set of
+     * {@code ImageOutputStreamSpi}s registered with the
+     * {@code IIORegistry} class is queried and the first one
      * that is able to send output from the supplied object is used to
-     * create the returned <code>ImageOutputStream</code>.  If no
-     * suitable <code>ImageOutputStreamSpi</code> exists,
-     * <code>null</code> is returned.
-     *
-     * <p> The current cache settings from <code>getUseCache</code>and
-     * <code>getCacheDirectory</code> will be used to control caching.
-     *
-     * @param output an <code>Object</code> to be used as an output
-     * destination, such as a <code>File</code>, writable
-     * <code>RandomAccessFile</code>, or <code>OutputStream</code>.
+     * create the returned {@code ImageOutputStream}.  If no
+     * suitable {@code ImageOutputStreamSpi} exists,
+     * {@code null} is returned.
+     *
+     * <p> The current cache settings from {@code getUseCache} and
+     * {@code getCacheDirectory} will be used to control caching.
+     *
+     * @param output an {@code Object} to be used as an output
+     * destination, such as a {@code File}, writable
+     * {@code RandomAccessFile}, or {@code OutputStream}.
      *
-     * @return an <code>ImageOutputStream</code>, or
-     * <code>null</code>.
+     * @return an {@code ImageOutputStream}, or
+     * {@code null}.
      *
-     * @exception IllegalArgumentException if <code>output</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code output} is
+     * {@code null}.
      * @exception IOException if a cache file is needed but cannot be
      * created.
      *
      * @see javax.imageio.spi.ImageOutputStreamSpi
      */

@@ -472,39 +472,39 @@
     }
 
     // Readers
 
     /**
-     * Returns an array of <code>String</code>s listing all of the
+     * Returns an array of {@code String}s listing all of the
      * informal format names understood by the current set of registered
      * readers.
      *
-     * @return an array of <code>String</code>s.
+     * @return an array of {@code String}s.
      */
     public static String[] getReaderFormatNames() {
         return getReaderWriterInfo(ImageReaderSpi.class,
                                    SpiInfo.FORMAT_NAMES);
     }
 
     /**
-     * Returns an array of <code>String</code>s listing all of the
+     * Returns an array of {@code String}s listing all of the
      * MIME types understood by the current set of registered
      * readers.
      *
-     * @return an array of <code>String</code>s.
+     * @return an array of {@code String}s.
      */
     public static String[] getReaderMIMETypes() {
         return getReaderWriterInfo(ImageReaderSpi.class,
                                    SpiInfo.MIME_TYPES);
     }
 
     /**
-     * Returns an array of <code>String</code>s listing all of the
+     * Returns an array of {@code String}s listing all of the
      * file suffixes associated with the formats understood
      * by the current set of registered readers.
      *
-     * @return an array of <code>String</code>s.
+     * @return an array of {@code String}s.
      * @since 1.6
      */
     public static String[] getReaderFileSuffixes() {
         return getReaderWriterInfo(ImageReaderSpi.class,
                                    SpiInfo.FILE_SUFFIXES);

@@ -616,25 +616,25 @@
             }
         }
     }
 
     /**
-     * Returns an <code>Iterator</code> containing all currently
-     * registered <code>ImageReader</code>s that claim to be able to
-     * decode the supplied <code>Object</code>, typically an
-     * <code>ImageInputStream</code>.
+     * Returns an {@code Iterator} containing all currently
+     * registered {@code ImageReader}s that claim to be able to
+     * decode the supplied {@code Object}, typically an
+     * {@code ImageInputStream}.
      *
      * <p> The stream position is left at its prior position upon
      * exit from this method.
      *
-     * @param input an <code>ImageInputStream</code> or other
-     * <code>Object</code> containing encoded image data.
+     * @param input an {@code ImageInputStream} or other
+     * {@code Object} containing encoded image data.
      *
-     * @return an <code>Iterator</code> containing <code>ImageReader</code>s.
+     * @return an {@code Iterator} containing {@code ImageReader}s.
      *
-     * @exception IllegalArgumentException if <code>input</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code input} is
+     * {@code null}.
      *
      * @see javax.imageio.spi.ImageReaderSpi#canDecodeInput
      */
     public static Iterator<ImageReader> getImageReaders(Object input) {
         if (input == null) {

@@ -679,22 +679,22 @@
             e.printStackTrace();
         }
     }
 
     /**
-     * Returns an <code>Iterator</code> containing all currently
-     * registered <code>ImageReader</code>s that claim to be able to
+     * Returns an {@code Iterator} containing all currently
+     * registered {@code ImageReader}s that claim to be able to
      * decode the named format.
      *
-     * @param formatName a <code>String</code> containing the informal
+     * @param formatName a {@code String} containing the informal
      * name of a format (<i>e.g.</i>, "jpeg" or "tiff".
      *
-     * @return an <code>Iterator</code> containing
-     * <code>ImageReader</code>s.
+     * @return an {@code Iterator} containing
+     * {@code ImageReader}s.
      *
-     * @exception IllegalArgumentException if <code>formatName</code>
-     * is <code>null</code>.
+     * @exception IllegalArgumentException if {@code formatName}
+     * is {@code null}.
      *
      * @see javax.imageio.spi.ImageReaderSpi#getFormatNames
      */
     public static Iterator<ImageReader>
         getImageReadersByFormatName(String formatName)

@@ -714,22 +714,22 @@
         }
         return new ImageReaderIterator(iter);
     }
 
     /**
-     * Returns an <code>Iterator</code> containing all currently
-     * registered <code>ImageReader</code>s that claim to be able to
+     * Returns an {@code Iterator} containing all currently
+     * registered {@code ImageReader}s that claim to be able to
      * decode files with the given suffix.
      *
-     * @param fileSuffix a <code>String</code> containing a file
+     * @param fileSuffix a {@code String} containing a file
      * suffix (<i>e.g.</i>, "jpg" or "tiff").
      *
-     * @return an <code>Iterator</code> containing
-     * <code>ImageReader</code>s.
+     * @return an {@code Iterator} containing
+     * {@code ImageReader}s.
      *
-     * @exception IllegalArgumentException if <code>fileSuffix</code>
-     * is <code>null</code>.
+     * @exception IllegalArgumentException if {@code fileSuffix}
+     * is {@code null}.
      *
      * @see javax.imageio.spi.ImageReaderSpi#getFileSuffixes
      */
     public static Iterator<ImageReader>
         getImageReadersBySuffix(String fileSuffix)

@@ -749,22 +749,22 @@
         }
         return new ImageReaderIterator(iter);
     }
 
     /**
-     * Returns an <code>Iterator</code> containing all currently
-     * registered <code>ImageReader</code>s that claim to be able to
+     * Returns an {@code Iterator} containing all currently
+     * registered {@code ImageReader}s that claim to be able to
      * decode files with the given MIME type.
      *
-     * @param MIMEType a <code>String</code> containing a file
+     * @param MIMEType a {@code String} containing a file
      * suffix (<i>e.g.</i>, "image/jpeg" or "image/x-bmp").
      *
-     * @return an <code>Iterator</code> containing
-     * <code>ImageReader</code>s.
+     * @return an {@code Iterator} containing
+     * {@code ImageReader}s.
      *
-     * @exception IllegalArgumentException if <code>MIMEType</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code MIMEType} is
+     * {@code null}.
      *
      * @see javax.imageio.spi.ImageReaderSpi#getMIMETypes
      */
     public static Iterator<ImageReader>
         getImageReadersByMIMEType(String MIMEType)

@@ -786,39 +786,39 @@
     }
 
     // Writers
 
     /**
-     * Returns an array of <code>String</code>s listing all of the
+     * Returns an array of {@code String}s listing all of the
      * informal format names understood by the current set of registered
      * writers.
      *
-     * @return an array of <code>String</code>s.
+     * @return an array of {@code String}s.
      */
     public static String[] getWriterFormatNames() {
         return getReaderWriterInfo(ImageWriterSpi.class,
                                    SpiInfo.FORMAT_NAMES);
     }
 
     /**
-     * Returns an array of <code>String</code>s listing all of the
+     * Returns an array of {@code String}s listing all of the
      * MIME types understood by the current set of registered
      * writers.
      *
-     * @return an array of <code>String</code>s.
+     * @return an array of {@code String}s.
      */
     public static String[] getWriterMIMETypes() {
         return getReaderWriterInfo(ImageWriterSpi.class,
                                    SpiInfo.MIME_TYPES);
     }
 
     /**
-     * Returns an array of <code>String</code>s listing all of the
+     * Returns an array of {@code String}s listing all of the
      * file suffixes associated with the formats understood
      * by the current set of registered writers.
      *
-     * @return an array of <code>String</code>s.
+     * @return an array of {@code String}s.
      * @since 1.6
      */
     public static String[] getWriterFileSuffixes() {
         return getReaderWriterInfo(ImageWriterSpi.class,
                                    SpiInfo.FILE_SUFFIXES);

@@ -862,22 +862,22 @@
 
         return false;
     }
 
     /**
-     * Returns an <code>Iterator</code> containing all currently
-     * registered <code>ImageWriter</code>s that claim to be able to
+     * Returns an {@code Iterator} containing all currently
+     * registered {@code ImageWriter}s that claim to be able to
      * encode the named format.
      *
-     * @param formatName a <code>String</code> containing the informal
+     * @param formatName a {@code String} containing the informal
      * name of a format (<i>e.g.</i>, "jpeg" or "tiff".
      *
-     * @return an <code>Iterator</code> containing
-     * <code>ImageWriter</code>s.
+     * @return an {@code Iterator} containing
+     * {@code ImageWriter}s.
      *
-     * @exception IllegalArgumentException if <code>formatName</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code formatName} is
+     * {@code null}.
      *
      * @see javax.imageio.spi.ImageWriterSpi#getFormatNames
      */
     public static Iterator<ImageWriter>
         getImageWritersByFormatName(String formatName)

@@ -897,21 +897,21 @@
         }
         return new ImageWriterIterator(iter);
     }
 
     /**
-     * Returns an <code>Iterator</code> containing all currently
-     * registered <code>ImageWriter</code>s that claim to be able to
+     * Returns an {@code Iterator} containing all currently
+     * registered {@code ImageWriter}s that claim to be able to
      * encode files with the given suffix.
      *
-     * @param fileSuffix a <code>String</code> containing a file
+     * @param fileSuffix a {@code String} containing a file
      * suffix (<i>e.g.</i>, "jpg" or "tiff").
      *
-     * @return an <code>Iterator</code> containing <code>ImageWriter</code>s.
+     * @return an {@code Iterator} containing {@code ImageWriter}s.
      *
-     * @exception IllegalArgumentException if <code>fileSuffix</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code fileSuffix} is
+     * {@code null}.
      *
      * @see javax.imageio.spi.ImageWriterSpi#getFileSuffixes
      */
     public static Iterator<ImageWriter>
         getImageWritersBySuffix(String fileSuffix)

@@ -931,21 +931,21 @@
         }
         return new ImageWriterIterator(iter);
     }
 
     /**
-     * Returns an <code>Iterator</code> containing all currently
-     * registered <code>ImageWriter</code>s that claim to be able to
+     * Returns an {@code Iterator} containing all currently
+     * registered {@code ImageWriter}s that claim to be able to
      * encode files with the given MIME type.
      *
-     * @param MIMEType a <code>String</code> containing a file
+     * @param MIMEType a {@code String} containing a file
      * suffix (<i>e.g.</i>, "image/jpeg" or "image/x-bmp").
      *
-     * @return an <code>Iterator</code> containing <code>ImageWriter</code>s.
+     * @return an {@code Iterator} containing {@code ImageWriter}s.
      *
-     * @exception IllegalArgumentException if <code>MIMEType</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code MIMEType} is
+     * {@code null}.
      *
      * @see javax.imageio.spi.ImageWriterSpi#getMIMETypes
      */
     public static Iterator<ImageWriter>
         getImageWritersByMIMEType(String MIMEType)

@@ -965,34 +965,34 @@
         }
         return new ImageWriterIterator(iter);
     }
 
     /**
-     * Returns an <code>ImageWriter</code>corresponding to the given
-     * <code>ImageReader</code>, if there is one, or <code>null</code>
-     * if the plug-in for this <code>ImageReader</code> does not
-     * specify a corresponding <code>ImageWriter</code>, or if the
-     * given <code>ImageReader</code> is not registered.  This
-     * mechanism may be used to obtain an <code>ImageWriter</code>
+     * Returns an {@code ImageWriter} corresponding to the given
+     * {@code ImageReader}, if there is one, or {@code null}
+     * if the plug-in for this {@code ImageReader} does not
+     * specify a corresponding {@code ImageWriter}, or if the
+     * given {@code ImageReader} is not registered.  This
+     * mechanism may be used to obtain an {@code ImageWriter}
      * that will understand the internal structure of non-pixel
-     * metadata (as encoded by <code>IIOMetadata</code> objects)
-     * generated by the <code>ImageReader</code>.  By obtaining this
-     * data from the <code>ImageReader</code> and passing it on to the
-     * <code>ImageWriter</code> obtained with this method, a client
+     * metadata (as encoded by {@code IIOMetadata} objects)
+     * generated by the {@code ImageReader}.  By obtaining this
+     * data from the {@code ImageReader} and passing it on to the
+     * {@code ImageWriter} obtained with this method, a client
      * program can read an image, modify it in some way, and write it
      * back out preserving all metadata, without having to understand
      * anything about the structure of the metadata, or even about
      * the image format.  Note that this method returns the
      * "preferred" writer, which is the first in the list returned by
-     * <code>javax.imageio.spi.ImageReaderSpi.getImageWriterSpiNames()</code>.
+     * {@code javax.imageio.spi.ImageReaderSpi.getImageWriterSpiNames()}.
      *
-     * @param reader an instance of a registered <code>ImageReader</code>.
+     * @param reader an instance of a registered {@code ImageReader}.
      *
-     * @return an <code>ImageWriter</code>, or null.
+     * @return an {@code ImageWriter}, or null.
      *
-     * @exception IllegalArgumentException if <code>reader</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code reader} is
+     * {@code null}.
      *
      * @see #getImageReader(ImageWriter)
      * @see javax.imageio.spi.ImageReaderSpi#getImageWriterSpiNames()
      */
     public static ImageWriter getImageWriter(ImageReader reader) {

@@ -1052,27 +1052,27 @@
             return null;
         }
     }
 
     /**
-     * Returns an <code>ImageReader</code>corresponding to the given
-     * <code>ImageWriter</code>, if there is one, or <code>null</code>
-     * if the plug-in for this <code>ImageWriter</code> does not
-     * specify a corresponding <code>ImageReader</code>, or if the
-     * given <code>ImageWriter</code> is not registered.  This method
+     * Returns an {@code ImageReader} corresponding to the given
+     * {@code ImageWriter}, if there is one, or {@code null}
+     * if the plug-in for this {@code ImageWriter} does not
+     * specify a corresponding {@code ImageReader}, or if the
+     * given {@code ImageWriter} is not registered.  This method
      * is provided principally for symmetry with
-     * <code>getImageWriter(ImageReader)</code>.  Note that this
+     * {@code getImageWriter(ImageReader)}.  Note that this
      * method returns the "preferred" reader, which is the first in
      * the list returned by
-     * javax.imageio.spi.ImageWriterSpi.<code>getImageReaderSpiNames()</code>.
+     * javax.imageio.spi.ImageWriterSpi.{@code getImageReaderSpiNames()}.
      *
-     * @param writer an instance of a registered <code>ImageWriter</code>.
+     * @param writer an instance of a registered {@code ImageWriter}.
      *
-     * @return an <code>ImageReader</code>, or null.
+     * @return an {@code ImageReader}, or null.
      *
-     * @exception IllegalArgumentException if <code>writer</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code writer} is
+     * {@code null}.
      *
      * @see #getImageWriter(ImageReader)
      * @see javax.imageio.spi.ImageWriterSpi#getImageReaderSpiNames()
      */
     public static ImageReader getImageReader(ImageWriter writer) {

@@ -1132,23 +1132,23 @@
             return null;
         }
     }
 
     /**
-     * Returns an <code>Iterator</code> containing all currently
-     * registered <code>ImageWriter</code>s that claim to be able to
+     * Returns an {@code Iterator} containing all currently
+     * registered {@code ImageWriter}s that claim to be able to
      * encode images of the given layout (specified using an
-     * <code>ImageTypeSpecifier</code>) in the given format.
+     * {@code ImageTypeSpecifier}) in the given format.
      *
-     * @param type an <code>ImageTypeSpecifier</code> indicating the
+     * @param type an {@code ImageTypeSpecifier} indicating the
      * layout of the image to be written.
-     * @param formatName the informal name of the <code>format</code>.
+     * @param formatName the informal name of the {@code format}.
      *
-     * @return an <code>Iterator</code> containing <code>ImageWriter</code>s.
+     * @return an {@code Iterator} containing {@code ImageWriter}s.
      *
      * @exception IllegalArgumentException if any parameter is
-     * <code>null</code>.
+     * {@code null}.
      *
      * @see javax.imageio.spi.ImageWriterSpi#canEncodeImage(ImageTypeSpecifier)
      */
     public static Iterator<ImageWriter>
         getImageWriters(ImageTypeSpecifier type, String formatName)

@@ -1219,23 +1219,23 @@
                     writerName.equals(writerSpiName));
         }
     }
 
     /**
-     * Returns an <code>Iterator</code> containing all currently
-     * registered <code>ImageTranscoder</code>s that claim to be
+     * Returns an {@code Iterator} containing all currently
+     * registered {@code ImageTranscoder}s that claim to be
      * able to transcode between the metadata of the given
-     * <code>ImageReader</code> and <code>ImageWriter</code>.
+     * {@code ImageReader} and {@code ImageWriter}.
      *
-     * @param reader an <code>ImageReader</code>.
-     * @param writer an <code>ImageWriter</code>.
+     * @param reader an {@code ImageReader}.
+     * @param writer an {@code ImageWriter}.
      *
-     * @return an <code>Iterator</code> containing
-     * <code>ImageTranscoder</code>s.
+     * @return an {@code Iterator} containing
+     * {@code ImageTranscoder}s.
      *
-     * @exception IllegalArgumentException if <code>reader</code> or
-     * <code>writer</code> is <code>null</code>.
+     * @exception IllegalArgumentException if {@code reader} or
+     * {@code writer} is {@code null}.
      */
     public static Iterator<ImageTranscoder>
         getImageTranscoders(ImageReader reader, ImageWriter writer)
     {
         if (reader == null) {

@@ -1261,38 +1261,38 @@
     }
 
     // All-in-one methods
 
     /**
-     * Returns a <code>BufferedImage</code> as the result of decoding
-     * a supplied <code>File</code> with an <code>ImageReader</code>
+     * Returns a {@code BufferedImage} as the result of decoding
+     * a supplied {@code File} with an {@code ImageReader}
      * chosen automatically from among those currently registered.
-     * The <code>File</code> is wrapped in an
-     * <code>ImageInputStream</code>.  If no registered
-     * <code>ImageReader</code> claims to be able to read the
-     * resulting stream, <code>null</code> is returned.
-     *
-     * <p> The current cache settings from <code>getUseCache</code>and
-     * <code>getCacheDirectory</code> will be used to control caching in the
-     * <code>ImageInputStream</code> that is created.
-     *
-     * <p> Note that there is no <code>read</code> method that takes a
-     * filename as a <code>String</code>; use this method instead after
-     * creating a <code>File</code> from the filename.
+     * The {@code File} is wrapped in an
+     * {@code ImageInputStream}.  If no registered
+     * {@code ImageReader} claims to be able to read the
+     * resulting stream, {@code null} is returned.
+     *
+     * <p> The current cache settings from {@code getUseCache} and
+     * {@code getCacheDirectory} will be used to control caching in the
+     * {@code ImageInputStream} that is created.
+     *
+     * <p> Note that there is no {@code read} method that takes a
+     * filename as a {@code String}; use this method instead after
+     * creating a {@code File} from the filename.
      *
      * <p> This method does not attempt to locate
-     * <code>ImageReader</code>s that can read directly from a
-     * <code>File</code>; that may be accomplished using
-     * <code>IIORegistry</code> and <code>ImageReaderSpi</code>.
+     * {@code ImageReader}s that can read directly from a
+     * {@code File}; that may be accomplished using
+     * {@code IIORegistry} and {@code ImageReaderSpi}.
      *
-     * @param input a <code>File</code> to read from.
+     * @param input a {@code File} to read from.
      *
-     * @return a <code>BufferedImage</code> containing the decoded
-     * contents of the input, or <code>null</code>.
+     * @return a {@code BufferedImage} containing the decoded
+     * contents of the input, or {@code null}.
      *
-     * @exception IllegalArgumentException if <code>input</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code input} is
+     * {@code null}.
      * @exception IOException if an error occurs during reading.
      */
     public static BufferedImage read(File input) throws IOException {
         if (input == null) {
             throw new IllegalArgumentException("input == null!");

@@ -1311,38 +1311,38 @@
         }
         return bi;
     }
 
     /**
-     * Returns a <code>BufferedImage</code> as the result of decoding
-     * a supplied <code>InputStream</code> with an <code>ImageReader</code>
+     * Returns a {@code BufferedImage} as the result of decoding
+     * a supplied {@code InputStream} with an {@code ImageReader}
      * chosen automatically from among those currently registered.
-     * The <code>InputStream</code> is wrapped in an
-     * <code>ImageInputStream</code>.  If no registered
-     * <code>ImageReader</code> claims to be able to read the
-     * resulting stream, <code>null</code> is returned.
-     *
-     * <p> The current cache settings from <code>getUseCache</code>and
-     * <code>getCacheDirectory</code> will be used to control caching in the
-     * <code>ImageInputStream</code> that is created.
+     * The {@code InputStream} is wrapped in an
+     * {@code ImageInputStream}.  If no registered
+     * {@code ImageReader} claims to be able to read the
+     * resulting stream, {@code null} is returned.
+     *
+     * <p> The current cache settings from {@code getUseCache} and
+     * {@code getCacheDirectory} will be used to control caching in the
+     * {@code ImageInputStream} that is created.
      *
      * <p> This method does not attempt to locate
-     * <code>ImageReader</code>s that can read directly from an
-     * <code>InputStream</code>; that may be accomplished using
-     * <code>IIORegistry</code> and <code>ImageReaderSpi</code>.
+     * {@code ImageReader}s that can read directly from an
+     * {@code InputStream}; that may be accomplished using
+     * {@code IIORegistry} and {@code ImageReaderSpi}.
      *
      * <p> This method <em>does not</em> close the provided
-     * <code>InputStream</code> after the read operation has completed;
+     * {@code InputStream} after the read operation has completed;
      * it is the responsibility of the caller to close the stream, if desired.
      *
-     * @param input an <code>InputStream</code> to read from.
+     * @param input an {@code InputStream} to read from.
      *
-     * @return a <code>BufferedImage</code> containing the decoded
-     * contents of the input, or <code>null</code>.
+     * @return a {@code BufferedImage} containing the decoded
+     * contents of the input, or {@code null}.
      *
-     * @exception IllegalArgumentException if <code>input</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code input} is
+     * {@code null}.
      * @exception IOException if an error occurs during reading.
      */
     public static BufferedImage read(InputStream input) throws IOException {
         if (input == null) {
             throw new IllegalArgumentException("input == null!");

@@ -1355,34 +1355,34 @@
         }
         return bi;
     }
 
     /**
-     * Returns a <code>BufferedImage</code> as the result of decoding
-     * a supplied <code>URL</code> with an <code>ImageReader</code>
+     * Returns a {@code BufferedImage} as the result of decoding
+     * a supplied {@code URL} with an {@code ImageReader}
      * chosen automatically from among those currently registered.  An
-     * <code>InputStream</code> is obtained from the <code>URL</code>,
-     * which is wrapped in an <code>ImageInputStream</code>.  If no
-     * registered <code>ImageReader</code> claims to be able to read
-     * the resulting stream, <code>null</code> is returned.
-     *
-     * <p> The current cache settings from <code>getUseCache</code>and
-     * <code>getCacheDirectory</code> will be used to control caching in the
-     * <code>ImageInputStream</code> that is created.
+     * {@code InputStream} is obtained from the {@code URL},
+     * which is wrapped in an {@code ImageInputStream}.  If no
+     * registered {@code ImageReader} claims to be able to read
+     * the resulting stream, {@code null} is returned.
+     *
+     * <p> The current cache settings from {@code getUseCache} and
+     * {@code getCacheDirectory} will be used to control caching in the
+     * {@code ImageInputStream} that is created.
      *
      * <p> This method does not attempt to locate
-     * <code>ImageReader</code>s that can read directly from a
-     * <code>URL</code>; that may be accomplished using
-     * <code>IIORegistry</code> and <code>ImageReaderSpi</code>.
+     * {@code ImageReader}s that can read directly from a
+     * {@code URL}; that may be accomplished using
+     * {@code IIORegistry} and {@code ImageReaderSpi}.
      *
-     * @param input a <code>URL</code> to read from.
+     * @param input a {@code URL} to read from.
      *
-     * @return a <code>BufferedImage</code> containing the decoded
-     * contents of the input, or <code>null</code>.
+     * @return a {@code BufferedImage} containing the decoded
+     * contents of the input, or {@code null}.
      *
-     * @exception IllegalArgumentException if <code>input</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code input} is
+     * {@code null}.
      * @exception IOException if an error occurs during reading.
      */
     public static BufferedImage read(URL input) throws IOException {
         if (input == null) {
             throw new IllegalArgumentException("input == null!");

@@ -1406,29 +1406,29 @@
         }
         return bi;
     }
 
     /**
-     * Returns a <code>BufferedImage</code> as the result of decoding
-     * a supplied <code>ImageInputStream</code> with an
-     * <code>ImageReader</code> chosen automatically from among those
+     * Returns a {@code BufferedImage} as the result of decoding
+     * a supplied {@code ImageInputStream} with an
+     * {@code ImageReader} chosen automatically from among those
      * currently registered.  If no registered
-     * <code>ImageReader</code> claims to be able to read the stream,
-     * <code>null</code> is returned.
+     * {@code ImageReader} claims to be able to read the stream,
+     * {@code null} is returned.
      *
      * <p> Unlike most other methods in this class, this method <em>does</em>
-     * close the provided <code>ImageInputStream</code> after the read
-     * operation has completed, unless <code>null</code> is returned,
+     * close the provided {@code ImageInputStream} after the read
+     * operation has completed, unless {@code null} is returned,
      * in which case this method <em>does not</em> close the stream.
      *
-     * @param stream an <code>ImageInputStream</code> to read from.
+     * @param stream an {@code ImageInputStream} to read from.
      *
-     * @return a <code>BufferedImage</code> containing the decoded
-     * contents of the input, or <code>null</code>.
+     * @return a {@code BufferedImage} containing the decoded
+     * contents of the input, or {@code null}.
      *
-     * @exception IllegalArgumentException if <code>stream</code> is
-     * <code>null</code>.
+     * @exception IllegalArgumentException if {@code stream} is
+     * {@code null}.
      * @exception IOException if an error occurs during reading.
      */
     public static BufferedImage read(ImageInputStream stream)
         throws IOException {
         if (stream == null) {

@@ -1452,30 +1452,30 @@
         }
         return bi;
     }
 
     /**
-     * Writes an image using the an arbitrary <code>ImageWriter</code>
+     * Writes an image using the an arbitrary {@code ImageWriter}
      * that supports the given format to an
-     * <code>ImageOutputStream</code>.  The image is written to the
-     * <code>ImageOutputStream</code> starting at the current stream
+     * {@code ImageOutputStream}.  The image is written to the
+     * {@code ImageOutputStream} starting at the current stream
      * pointer, overwriting existing stream data from that point
      * forward, if present.
      *
      * <p> This method <em>does not</em> close the provided
-     * <code>ImageOutputStream</code> after the write operation has completed;
+     * {@code ImageOutputStream} after the write operation has completed;
      * it is the responsibility of the caller to close the stream, if desired.
      *
-     * @param im a <code>RenderedImage</code> to be written.
-     * @param formatName a <code>String</code> containing the informal
+     * @param im a {@code RenderedImage} to be written.
+     * @param formatName a {@code String} containing the informal
      * name of the format.
-     * @param output an <code>ImageOutputStream</code> to be written to.
+     * @param output an {@code ImageOutputStream} to be written to.
      *
-     * @return <code>false</code> if no appropriate writer is found.
+     * @return {@code false} if no appropriate writer is found.
      *
      * @exception IllegalArgumentException if any parameter is
-     * <code>null</code>.
+     * {@code null}.
      * @exception IOException if an error occurs during writing.
      */
     public static boolean write(RenderedImage im,
                                 String formatName,
                                 ImageOutputStream output) throws IOException {

@@ -1491,24 +1491,24 @@
 
         return doWrite(im, getWriter(im, formatName), output);
     }
 
     /**
-     * Writes an image using an arbitrary <code>ImageWriter</code>
-     * that supports the given format to a <code>File</code>.  If
-     * there is already a <code>File</code> present, its contents are
+     * Writes an image using an arbitrary {@code ImageWriter}
+     * that supports the given format to a {@code File}.  If
+     * there is already a {@code File} present, its contents are
      * discarded.
      *
-     * @param im a <code>RenderedImage</code> to be written.
-     * @param formatName a <code>String</code> containing the informal
+     * @param im a {@code RenderedImage} to be written.
+     * @param formatName a {@code String} containing the informal
      * name of the format.
-     * @param output a <code>File</code> to be written to.
+     * @param output a {@code File} to be written to.
      *
-     * @return <code>false</code> if no appropriate writer is found.
+     * @return {@code false} if no appropriate writer is found.
      *
      * @exception IllegalArgumentException if any parameter is
-     * <code>null</code>.
+     * {@code null}.
      * @exception IOException if an error occurs during writing.
      */
     public static boolean write(RenderedImage im,
                                 String formatName,
                                 File output) throws IOException {

@@ -1538,29 +1538,29 @@
             stream.close();
         }
     }
 
     /**
-     * Writes an image using an arbitrary <code>ImageWriter</code>
-     * that supports the given format to an <code>OutputStream</code>.
+     * Writes an image using an arbitrary {@code ImageWriter}
+     * that supports the given format to an {@code OutputStream}.
      *
      * <p> This method <em>does not</em> close the provided
-     * <code>OutputStream</code> after the write operation has completed;
+     * {@code OutputStream} after the write operation has completed;
      * it is the responsibility of the caller to close the stream, if desired.
      *
-     * <p> The current cache settings from <code>getUseCache</code>and
-     * <code>getCacheDirectory</code> will be used to control caching.
+     * <p> The current cache settings from {@code getUseCache} and
+     * {@code getCacheDirectory} will be used to control caching.
      *
-     * @param im a <code>RenderedImage</code> to be written.
-     * @param formatName a <code>String</code> containing the informal
+     * @param im a {@code RenderedImage} to be written.
+     * @param formatName a {@code String} containing the informal
      * name of the format.
-     * @param output an <code>OutputStream</code> to be written to.
+     * @param output an {@code OutputStream} to be written to.
      *
-     * @return <code>false</code> if no appropriate writer is found.
+     * @return {@code false} if no appropriate writer is found.
      *
      * @exception IllegalArgumentException if any parameter is
-     * <code>null</code>.
+     * {@code null}.
      * @exception IOException if an error occurs during writing.
      */
     public static boolean write(RenderedImage im,
                                 String formatName,
                                 OutputStream output) throws IOException {

@@ -1580,12 +1580,12 @@
             stream.close();
         }
     }
 
     /**
-     * Returns <code>ImageWriter</code> instance according to given
-     * rendered image and image format or <code>null</code> if there
+     * Returns {@code ImageWriter} instance according to given
+     * rendered image and image format or {@code null} if there
      * is no appropriate writer.
      */
     private static ImageWriter getWriter(RenderedImage im,
                                          String formatName) {
         ImageTypeSpecifier type =
< prev index next >