* Returns an array of <code>String</code>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.     * @since 1.6     */    public static String[] getReaderFileSuffixes() {        return getReaderWriterInfo(ImageReaderSpi.class,                                   SpiInfo.FILE_SUFFIXES);    }     static class ImageReaderIterator implements Iterator<ImageReader> {        // Contains ImageReaderSpis        public Iterator iter;         public ImageReaderIterator(Iterator iter) {            this.iter = iter;        }         public boolean hasNext() {            return iter.hasNext();        }         public ImageReader next() {            ImageReaderSpi spi = null;            try {                spi = (ImageReaderSpi)iter.next();                return spi.createReaderInstance();            } catch (IOException e) {                // Deregister the spi in this case, but only as                // an ImageReaderSpi                theRegistry.deregisterServiceProvider(spi, ImageReaderSpi.class);            }            return null;        }         public void remove() {            throw new UnsupportedOperationException();        }    }     static class CanDecodeInputFilter        implements ServiceRegistry.Filter {         Object input;         public CanDecodeInputFilter(Object input) {            this.input = input;        }         public boolean filter(Object elt) {            try {                ImageReaderSpi spi = (ImageReaderSpi)elt;                ImageInputStream stream = null;                if (input instanceof ImageInputStream) {                    stream = (ImageInputStream)input;                }                 // Perform mark/reset as a defensive measure                // even though plug-ins are supposed to take                // care of it.                boolean canDecode = false;                if (stream != null) {                    stream.mark();                }                canDecode = spi.canDecodeInput(input);                if (stream != null) {                    stream.reset();                }                 return canDecode;            } catch (IOException e) {                return false;            }        }    }     static class CanEncodeImageAndFormatFilter        implements ServiceRegistry.Filter {         ImageTypeSpecifier type;        String formatName;         public CanEncodeImageAndFormatFilter(ImageTypeSpecifier type,                                             String formatName) {            this.type = type;            this.formatName = formatName;        }         public boolean filter(Object elt) {            ImageWriterSpi spi = (ImageWriterSpi)elt;            return Arrays.asList(spi.getFormatNames()).contains(formatName) &&                spi.canEncodeImage(type);        }    }     static class ContainsFilter        implements ServiceRegistry.Filter {         Method method;        String name;         // method returns an array of Strings        public ContainsFilter(Method method,                              String name) {            this.method = method;            this.name = name;        }         public boolean filter(Object elt) {            try {                return contains((String[])method.invoke(elt), name);            } catch (Exception e) {                return false;            }        }    }     /**     * 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>.     *     * <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.     *     * @return an <code>Iterator</code> containing <code>ImageReader</code>s.     *     * @exception IllegalArgumentException if <code>input</code> is     * <code>null</code>.     *     * @see javax.imageio.spi.ImageReaderSpi#canDecodeInput     */    public static Iterator<ImageReader> getImageReaders(Object input) {        if (input == null) {            throw new IllegalArgumentException("input == null!");        }        Iterator iter;        // Ensure category is present        try {            iter = theRegistry.getServiceProviders(ImageReaderSpi.class,                                              new CanDecodeInputFilter(input),                                              true);        } catch (IllegalArgumentException e) {            return Collections.emptyIterator();        }         return new ImageReaderIterator(iter);    }     private static Method readerFormatNamesMethod;    private static Method readerFileSuffixesMethod;    private static Method readerMIMETypesMethod;    private static Method writerFormatNamesMethod;    private static Method writerFileSuffixesMethod;    private static Method writerMIMETypesMethod;     static {        try {            readerFormatNamesMethod =                ImageReaderSpi.class.getMethod("getFormatNames");            readerFileSuffixesMethod =                ImageReaderSpi.class.getMethod("getFileSuffixes");            readerMIMETypesMethod =                ImageReaderSpi.class.getMethod("getMIMETypes");             writerFormatNamesMethod =                ImageWriterSpi.class.getMethod("getFormatNames");            writerFileSuffixesMethod =                ImageWriterSpi.class.getMethod("getFileSuffixes");            writerMIMETypesMethod =                ImageWriterSpi.class.getMethod("getMIMETypes");        } catch (NoSuchMethodException e) {            e.printStackTrace();        }    }     /**     * Returns an <code>Iterator</code> containing all currently     * registered <code>ImageReader</code>s that claim to be able to     * decode the named format.     *     * @param formatName a <code>String</code> containing the informal     * name of a format (<i>e.g.</i>, "jpeg" or "tiff".     *     * @return an <code>Iterator</code> containing     * <code>ImageReader</code>s.     *     * @exception IllegalArgumentException if <code>formatName</code>     * is <code>null</code>.     *     * @see javax.imageio.spi.ImageReaderSpi#getFormatNames     */    public static Iterator<ImageReader>        getImageReadersByFormatName(String formatName)    {        if (formatName == null) {            throw new IllegalArgumentException("formatName == null!");        }        Iterator iter;        // Ensure category is present        try {            iter = theRegistry.getServiceProviders(ImageReaderSpi.class,                                    new ContainsFilter(readerFormatNamesMethod,                                                       formatName),                                                true);        } catch (IllegalArgumentException e) {            return Collections.emptyIterator();        }        return new ImageReaderIterator(iter);    }     /**     * Returns an <code>Iterator</code> containing all currently     * registered <code>ImageReader</code>s that claim to be able to     * decode files with the given suffix.     *     * @param fileSuffix a <code>String</code> containing a file     * suffix (<i>e.g.</i>, "jpg" or "tiff").     *     * @return an <code>Iterator</code> containing     * <code>ImageReader</code>s.     *     * @exception IllegalArgumentException if <code>fileSuffix</code>     * is <code>null</code>.     *     * @see javax.imageio.spi.ImageReaderSpi#getFileSuffixes     */    public static Iterator<ImageReader>        getImageReadersBySuffix(String fileSuffix)    {        if (fileSuffix == null) {            throw new IllegalArgumentException("fileSuffix == null!");        }        // Ensure category is present        Iterator iter;        try {            iter = theRegistry.getServiceProviders(ImageReaderSpi.class,                                   new ContainsFilter(readerFileSuffixesMethod,                                                      fileSuffix),                                              true);        } catch (IllegalArgumentException e) {            return Collections.emptyIterator();        }        return new ImageReaderIterator(iter);    }     /**     * Returns an <code>Iterator</code> containing all currently     * registered <code>ImageReader</code>s that claim to be able to     * decode files with the given MIME type.     *     * @param MIMEType a <code>String</code> containing a file     * suffix (<i>e.g.</i>, "image/jpeg" or "image/x-bmp").     *     * @return an <code>Iterator</code> containing     * <code>ImageReader</code>s.     *     * @exception IllegalArgumentException if <code>MIMEType</code> is     * <code>null</code>.     *     * @see javax.imageio.spi.ImageReaderSpi#getMIMETypes     */    public static Iterator<ImageReader>        getImageReadersByMIMEType(String MIMEType)    {        if (MIMEType == null) {            throw new IllegalArgumentException("MIMEType == null!");        }        // Ensure category is present        Iterator iter;        try {            iter = theRegistry.getServiceProviders(ImageReaderSpi.class,                                      new ContainsFilter(readerMIMETypesMethod,                                                         MIMEType),                                              true);        } catch (IllegalArgumentException e) {            return Collections.emptyIterator();        }        return new ImageReaderIterator(iter);    }     // Writers     /**     * Returns an array of <code>String</code>s listing all of the     * informal format names understood by the current set of registered     * writers.     *     * @return an array of <code>String</code>s.     */    public static String[] getWriterFormatNames() {        return getReaderWriterInfo(ImageWriterSpi.class,                                   SpiInfo.FORMAT_NAMES);    }     /**     * Returns an array of <code>String</code>s listing all of the     * MIME types understood by the current set of registered     * writers.     *     * @return an array of <code>String</code>s.     */    public static String[] getWriterMIMETypes() {        return getReaderWriterInfo(ImageWriterSpi.class,                                   SpiInfo.MIME_TYPES);    }     /**     * Returns an array of <code>String</code>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.     * @since 1.6     */    public static String[] getWriterFileSuffixes() {        return getReaderWriterInfo(ImageWriterSpi.class,                                   SpiInfo.FILE_SUFFIXES);    }     static class ImageWriterIterator implements Iterator<ImageWriter> {        // Contains ImageWriterSpis        public Iterator iter;         public ImageWriterIterator(Iterator iter) {            this.iter = iter;        }         public boolean hasNext() {            return iter.hasNext();        }         public ImageWriter next() {            ImageWriterSpi spi = null;            try {                spi = (ImageWriterSpi)iter.next();                return spi.createWriterInstance();            } catch (IOException e) {                // Deregister the spi in this case, but only as a writerSpi                theRegistry.deregisterServiceProvider(spi, ImageWriterSpi.class);            }            return null;        }         public void remove() {            throw new UnsupportedOperationException();        }    }     private static boolean contains(String[] names, String name) {        for (int i = 0; i < names.length; i++) {            if (name.equalsIgnoreCase(names[i])) {                return true;            }        }         return false;    }     /**     * Returns an <code>Iterator</code> containing all currently     * registered <code>ImageWriter</code>s that claim to be able to     * encode the named format.     *     * @param formatName a <code>String</code> containing the informal     * name of a format (<i>e.g.</i>, "jpeg" or "tiff".     *     * @return an <code>Iterator</code> containing     * <code>ImageWriter</code>s.     *     * @exception IllegalArgumentException if <code>formatName</code> is     * <code>null</code>.     *     * @see javax.imageio.spi.ImageWriterSpi#getFormatNames     */    public static Iterator<ImageWriter>        getImageWritersByFormatName(String formatName)    {        if (formatName == null) {            throw new IllegalArgumentException("formatName == null!");        }        Iterator iter;        // Ensure category is present        try {            iter = theRegistry.getServiceProviders(ImageWriterSpi.class,                                    new ContainsFilter(writerFormatNamesMethod,                                                       formatName),                                            true);        } catch (IllegalArgumentException e) {            return Collections.emptyIterator();        }        return new ImageWriterIterator(iter);    }     /**     * Returns an <code>Iterator</code> containing all currently     * registered <code>ImageWriter</code>s that claim to be able to     * encode files with the given suffix.     *     * @param fileSuffix a <code>String</code> containing a file     * suffix (<i>e.g.</i>, "jpg" or "tiff").     *     * @return an <code>Iterator</code> containing <code>ImageWriter</code>s.     *     * @exception IllegalArgumentException if <code>fileSuffix</code> is     * <code>null</code>.     *     * @see javax.imageio.spi.ImageWriterSpi#getFileSuffixes     */    public static Iterator<ImageWriter>        getImageWritersBySuffix(String fileSuffix)    {        if (fileSuffix == null) {            throw new IllegalArgumentException("fileSuffix == null!");        }        Iterator iter;        // Ensure category is present        try {            iter = theRegistry.getServiceProviders(ImageWriterSpi.class,                                   new ContainsFilter(writerFileSuffixesMethod,                                                      fileSuffix),                                            true);        } catch (IllegalArgumentException e) {            return Collections.emptyIterator();        }        return new ImageWriterIterator(iter);    }     /**     * Returns an <code>Iterator</code> containing all currently     * registered <code>ImageWriter</code>s that claim to be able to     * encode files with the given MIME type.     *     * @param MIMEType a <code>String</code> containing a file     * suffix (<i>e.g.</i>, "image/jpeg" or "image/x-bmp").     *     * @return an <code>Iterator</code> containing <code>ImageWriter</code>s.     *     * @exception IllegalArgumentException if <code>MIMEType</code> is     * <code>null</code>.     *     * @see javax.imageio.spi.ImageWriterSpi#getMIMETypes     */    public static Iterator<ImageWriter>        getImageWritersByMIMEType(String MIMEType)    {        if (MIMEType == null) {            throw new IllegalArgumentException("MIMEType == null!");        }        Iterator iter;        // Ensure category is present        try {            iter = theRegistry.getServiceProviders(ImageWriterSpi.class,                                      new ContainsFilter(writerMIMETypesMethod,                                                         MIMEType),                                            true);        } catch (IllegalArgumentException e) {            return Collections.emptyIterator();        }        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>     * 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     * 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>.     *     * @param reader an instance of a registered <code>ImageReader</code>.     *     * @return an <code>ImageWriter</code>, or null.     *     * @exception IllegalArgumentException if <code>reader</code> is     * <code>null</code>.     *     * @see #getImageReader(ImageWriter)     * @see javax.imageio.spi.ImageReaderSpi#getImageWriterSpiNames()     */    public static ImageWriter getImageWriter(ImageReader reader) {        if (reader == null) {            throw new IllegalArgumentException("reader == null!");

Lines 501–1000 of 1619. Previous lines Load more