java类javax.imageio.spi.ImageWriterSpi的实例源码

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

    Iterator iter;
    // Ensure category is present
    try {
        iter = theRegistry.getServiceProviders(ImageWriterSpi.class,
                             new CanEncodeImageAndFormatFilter(type,
                                                               formatName),
                                        true);
    } catch (IllegalArgumentException e) {
        return Collections.emptyIterator();
    }

    return new ImageWriterIterator(iter);
}

/**
 * Returns an <code>Iterator</code> containing all currently
 * registered <code>ImageTranscoder</code>s that claim to be
 * able to transcode between the metadata of the given
 * <code>ImageReader</code> and <code>ImageWriter</code>.
 *
 * @param reader an <code>ImageReader</code>.
 * @param writer an <code>ImageWriter</code>.
 *
 * @return an <code>Iterator</code> containing
 * <code>ImageTranscoder</code>s.
 *
 * @exception IllegalArgumentException if <code>reader</code> or
 * <code>writer</code> is <code>null</code>.
 */
public static Iterator<ImageTranscoder>
    getImageTranscoders(ImageReader reader, ImageWriter writer)
{
    if (reader == null) {
        throw new IllegalArgumentException("reader == null!");
    }
    if (writer == null) {
        throw new IllegalArgumentException("writer == null!");
    }
    ImageReaderSpi readerSpi = reader.getOriginatingProvider();
    ImageWriterSpi writerSpi = writer.getOriginatingProvider();
    ServiceRegistry.Filter filter =
        new TranscoderFilter(readerSpi, writerSpi);

    Iterator iter;
    // Ensure category is present
    try {
        iter = theRegistry.getServiceProviders(ImageTranscoderSpi.class,
                                        filter, true);
    } catch (IllegalArgumentException e) {
        return Collections.emptyIterator();
    }
    return new ImageTranscoderIterator(iter);
}

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

    Iterator iter;
    // Ensure category is present
    try {
        iter = theRegistry.getServiceProviders(ImageWriterSpi.class,
                             new CanEncodeImageAndFormatFilter(type,
                                                               formatName),
                                        true);
    } catch (IllegalArgumentException e) {
        return Collections.emptyIterator();
    }

    return new ImageWriterIterator(iter);
}

/**
 * Returns an <code>Iterator</code> containing all currently
 * registered <code>ImageTranscoder</code>s that claim to be
 * able to transcode between the metadata of the given
 * <code>ImageReader</code> and <code>ImageWriter</code>.
 *
 * @param reader an <code>ImageReader</code>.
 * @param writer an <code>ImageWriter</code>.
 *
 * @return an <code>Iterator</code> containing
 * <code>ImageTranscoder</code>s.
 *
 * @exception IllegalArgumentException if <code>reader</code> or
 * <code>writer</code> is <code>null</code>.
 */
public static Iterator<ImageTranscoder>
    getImageTranscoders(ImageReader reader, ImageWriter writer)
{
    if (reader == null) {
        throw new IllegalArgumentException("reader == null!");
    }
    if (writer == null) {
        throw new IllegalArgumentException("writer == null!");
    }
    ImageReaderSpi readerSpi = reader.getOriginatingProvider();
    ImageWriterSpi writerSpi = writer.getOriginatingProvider();
    ServiceRegistry.Filter filter =
        new TranscoderFilter(readerSpi, writerSpi);

    Iterator iter;
    // Ensure category is present
    try {
        iter = theRegistry.getServiceProviders(ImageTranscoderSpi.class,
                                        filter, true);
    } catch (IllegalArgumentException e) {
        return Collections.emptyIterator();
    }
    return new ImageTranscoderIterator(iter);
}

public void doTest() {
    File pwd = new File(".");
    try {
        File f = File.createTempFile("transparency_test_", ".gif", pwd);
        System.out.println("file: " + f.getCanonicalPath());

        ImageWriter w = ImageIO.getImageWritersByFormatName("GIF").next();

        ImageWriterSpi spi = w.getOriginatingProvider();

        boolean succeed_write = ImageIO.write(src, "gif", f);

        if (!succeed_write) {
            throw new RuntimeException("Test failed: failed to write src.");
        }

        dst = ImageIO.read(f);

        checkResult(src, dst);

    } catch (IOException e) {
        throw new RuntimeException("Test failed.", e);
    }
}

/**
 * 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} containing the informal
 * name of a format (<i>e.g.</i>, "jpeg" or "tiff".
 *
 * @return an {@code Iterator} containing
 * {@code ImageWriter}s.
 *
 * @exception IllegalArgumentException if {@code formatName} is
 * {@code null}.
 *
 * @see javax.imageio.spi.ImageWriterSpi#getFormatNames
 */
public static Iterator<ImageWriter>
    getImageWritersByFormatName(String formatName)
{
    if (formatName == null) {
        throw new IllegalArgumentException("formatName == null!");
    }
    Iterator<ImageWriterSpi> 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} containing all currently
 * registered {@code ImageWriter}s that claim to be able to
 * encode files with the given suffix.
 *
 * @param fileSuffix a {@code String} containing a file
 * suffix (<i>e.g.</i>, "jpg" or "tiff").
 *
 * @return an {@code Iterator} containing {@code ImageWriter}s.
 *
 * @exception IllegalArgumentException if {@code fileSuffix} is
 * {@code null}.
 *
 * @see javax.imageio.spi.ImageWriterSpi#getFileSuffixes
 */
public static Iterator<ImageWriter>
    getImageWritersBySuffix(String fileSuffix)
{
    if (fileSuffix == null) {
        throw new IllegalArgumentException("fileSuffix == null!");
    }
    Iterator<ImageWriterSpi> 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} 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} containing a file
 * suffix (<i>e.g.</i>, "image/jpeg" or "image/x-bmp").
 *
 * @return an {@code Iterator} containing {@code ImageWriter}s.
 *
 * @exception IllegalArgumentException if {@code MIMEType} is
 * {@code null}.
 *
 * @see javax.imageio.spi.ImageWriterSpi#getMIMETypes
 */
public static Iterator<ImageWriter>
    getImageWritersByMIMEType(String MIMEType)
{
    if (MIMEType == null) {
        throw new IllegalArgumentException("MIMEType == null!");
    }
    Iterator<ImageWriterSpi> 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 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}) in the given format.
 *
 * @param type an {@code ImageTypeSpecifier} indicating the
 * layout of the image to be written.
 * @param formatName the informal name of the {@code format}.
 *
 * @return an {@code Iterator} containing {@code ImageWriter}s.
 *
 * @exception IllegalArgumentException if any parameter is
 * {@code null}.
 *
 * @see javax.imageio.spi.ImageWriterSpi#canEncodeImage(ImageTypeSpecifier)
 */
public static Iterator<ImageWriter>
    getImageWriters(ImageTypeSpecifier type, String formatName)
{
    if (type == null) {
        throw new IllegalArgumentException("type == null!");
    }
    if (formatName == null) {
        throw new IllegalArgumentException("formatName == null!");
    }

    Iterator<ImageWriterSpi> iter;
    // Ensure category is present
    try {
        iter = theRegistry.getServiceProviders(ImageWriterSpi.class,
                             new CanEncodeImageAndFormatFilter(type,
                                                               formatName),
                                        true);
    } catch (IllegalArgumentException e) {
        return Collections.emptyIterator();
    }

    return new ImageWriterIterator(iter);
}

/**
 * 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} and {@code ImageWriter}.
 *
 * @param reader an {@code ImageReader}.
 * @param writer an {@code ImageWriter}.
 *
 * @return an {@code Iterator} containing
 * {@code ImageTranscoder}s.
 *
 * @exception IllegalArgumentException if {@code reader} or
 * {@code writer} is {@code null}.
 */
public static Iterator<ImageTranscoder>
    getImageTranscoders(ImageReader reader, ImageWriter writer)
{
    if (reader == null) {
        throw new IllegalArgumentException("reader == null!");
    }
    if (writer == null) {
        throw new IllegalArgumentException("writer == null!");
    }
    ImageReaderSpi readerSpi = reader.getOriginatingProvider();
    ImageWriterSpi writerSpi = writer.getOriginatingProvider();
    ServiceRegistry.Filter filter =
        new TranscoderFilter(readerSpi, writerSpi);

    Iterator<ImageTranscoderSpi> iter;
    // Ensure category is present
    try {
        iter = theRegistry.getServiceProviders(ImageTranscoderSpi.class,
                                        filter, true);
    } catch (IllegalArgumentException e) {
        return Collections.emptyIterator();
    }
    return new ImageTranscoderIterator(iter);
}

public SpiTest() {
    testImageReaderSpiConstructor();
    testImageWriterSpiConstructor();

    ServiceRegistry registry = IIORegistry.getDefaultInstance();
    Iterator readers = registry.getServiceProviders(ImageReaderSpi.class,
                                                    false);
    while (readers.hasNext()) {
        ImageReaderSpi rspi = (ImageReaderSpi)readers.next();
        System.out.println("*** Testing " + rspi.getClass().getName());
        testSpi(rspi);
    }

    Iterator writers = registry.getServiceProviders(ImageWriterSpi.class,
                                                    false);
    while (writers.hasNext()) {
        ImageWriterSpi wspi = (ImageWriterSpi)writers.next();
        System.out.println("*** Testing " + wspi.getClass().getName());
        testSpi(wspi);
    }
}

public static void main(String[] args) {
    ImageReaderSpi rspi = new PNGImageReaderSpi();
    if (rspi.getNativeStreamMetadataFormatName() != null) {
        fatal();
    }
    if (rspi.isStandardStreamMetadataFormatSupported() != false) {
        fatal();
    }
    if (rspi.getExtraStreamMetadataFormatNames() != null) {
        fatal();
    }

    ImageWriterSpi wspi = new PNGImageWriterSpi();
    if (wspi.getNativeStreamMetadataFormatName() != null) {
        fatal();
    }
    if (wspi.isStandardStreamMetadataFormatSupported() != false) {
        fatal();
    }
    if (wspi.getExtraStreamMetadataFormatNames() != null) {
        fatal();
    }
}

public void doTest() {
    File pwd = new File(".");
    try {
        File f = File.createTempFile("transparency_test_", ".gif", pwd);
        System.out.println("file: " + f.getCanonicalPath());

        ImageWriter w = ImageIO.getImageWritersByFormatName("GIF").next();

        ImageWriterSpi spi = w.getOriginatingProvider();

        boolean succeed_write = ImageIO.write(src, "gif", f);

        if (!succeed_write) {
            throw new RuntimeException("Test failed: failed to write src.");
        }

        dst = ImageIO.read(f);

        checkResult(src, dst);

    } catch (IOException e) {
        throw new RuntimeException("Test failed.", e);
    }
}

public static void main(final String[] args) throws IOException {
    final IIORegistry registry = IIORegistry.getDefaultInstance();
    final Iterator<ImageWriterSpi> iter = registry.getServiceProviders(
            ImageWriterSpi.class, provider -> true, true);

    // Validates all supported ImageWriters
    int numFailures = 0;
    while (iter.hasNext()) {
        final WriteAfterAbort writeAfterAbort = new WriteAfterAbort();
        final ImageWriter writer = iter.next().createWriterInstance();
        System.out.println("ImageWriter = " + writer);
        try {
            writeAfterAbort.test(writer);
        } catch (Exception e) {
            System.err.println("Test failed for \""
                + writer.getOriginatingProvider().getFormatNames()[0]
                + "\" format.");
            numFailures++;
        }
    }
    if (numFailures == 0) {
        System.out.println("Test passed.");
    } else {
        throw new RuntimeException("Test failed.");
    }
}

/**
 * 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} containing the informal
 * name of a format (<i>e.g.</i>, "jpeg" or "tiff".
 *
 * @return an {@code Iterator} containing
 * {@code ImageWriter}s.
 *
 * @exception IllegalArgumentException if {@code formatName} is
 * {@code null}.
 *
 * @see javax.imageio.spi.ImageWriterSpi#getFormatNames
 */
public static Iterator<ImageWriter>
    getImageWritersByFormatName(String formatName)
{
    if (formatName == null) {
        throw new IllegalArgumentException("formatName == null!");
    }
    Iterator<ImageWriterSpi> 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} 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} containing a file
 * suffix (<i>e.g.</i>, "image/jpeg" or "image/x-bmp").
 *
 * @return an {@code Iterator} containing {@code ImageWriter}s.
 *
 * @exception IllegalArgumentException if {@code MIMEType} is
 * {@code null}.
 *
 * @see javax.imageio.spi.ImageWriterSpi#getMIMETypes
 */
public static Iterator<ImageWriter>
    getImageWritersByMIMEType(String MIMEType)
{
    if (MIMEType == null) {
        throw new IllegalArgumentException("MIMEType == null!");
    }
    Iterator<ImageWriterSpi> 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);
}

public void doTest() {
    File pwd = new File(".");
    try {
        File f = File.createTempFile("transparency_test_", ".gif", pwd);
        System.out.println("file: " + f.getCanonicalPath());

        ImageWriter w = ImageIO.getImageWritersByFormatName("GIF").next();

        ImageWriterSpi spi = w.getOriginatingProvider();

        boolean succeed_write = ImageIO.write(src, "gif", f);

        if (!succeed_write) {
            throw new RuntimeException("Test failed: failed to write src.");
        }

        dst = ImageIO.read(f);

        checkResult(src, dst);

    } catch (IOException e) {
        throw new RuntimeException("Test failed.", e);
    }
}

/**
 * Retrieve all the MIME types supported by the collection of
 * registered image writers.
 *
 * @return an array of MIME types
 */
public static String[] getWriterMIMETypes()
{
  try
    {
      Iterator it =
        getRegistry().getServiceProviders(ImageWriterSpi.class, true);
      ArrayList result = new ArrayList();

      while (it.hasNext())
        {
          ImageWriterSpi spi = (ImageWriterSpi) it.next();
          String[] names = spi.getMIMETypes();

          for (int i = names.length - 1; i >= 0; --i)
            result.add(names[i]);
        }

      return (String[]) result.toArray(new String[result.size()]);
    }
  catch (IllegalArgumentException e)
    {
      return new String[0];
    }
}

/**
 * Retrieve all the informal format names supported by the
 * collection of registered image writers.
 *
 * @return an array of format names
 */
public static String[] getWriterFormatNames()
{
  try
    {
      Iterator it =
        getRegistry().getServiceProviders(ImageWriterSpi.class, true);
      ArrayList result = new ArrayList();

      while (it.hasNext())
        {
          ImageWriterSpi spi = (ImageWriterSpi) it.next();
          String[] names = spi.getFormatNames();

          for (int i = names.length - 1; i >= 0; --i)
            result.add(names[i]);
        }

      return (String[]) result.toArray(new String[result.size()]);
    }
  catch (IllegalArgumentException e)
    {
      return new String[0];
    }
}

/**
 * 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 images of the given layout (specified using an
 * <code>ImageTypeSpecifier</code>) in the given format.
 *
 * @param type an <code>ImageTypeSpecifier</code> indicating the
 * layout of the image to be written.
 * @param formatName the informal name of the <code>format</code>.
 *
 * @return an <code>Iterator</code> containing <code>ImageWriter</code>s.
 *
 * @exception IllegalArgumentException if any parameter is
 * <code>null</code>.
 *
 * @see javax.imageio.spi.ImageWriterSpi#canEncodeImage(ImageTypeSpecifier)
 */
public static Iterator<ImageWriter>
    getImageWriters(ImageTypeSpecifier type, String formatName)
{
    if (type == null) {
        throw new IllegalArgumentException("type == null!");
    }
    if (formatName == null) {
        throw new IllegalArgumentException("formatName == null!");
    }

    Iterator iter;
    // Ensure category is present
    try {
        iter = theRegistry.getServiceProviders(ImageWriterSpi.class,
                             new CanEncodeImageAndFormatFilter(type,
                                                               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 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);
}

/**
 * Retrieve an image reader corresponding to an image writer, or
 * null if writer is not registered or if no corresponding reader is
 * registered.
 *
 * @param writer a registered image writer
 *
 * @return an image reader corresponding to writer, or null
 *
 * @exception IllegalArgumentException if writer is null
 */
public static ImageReader getImageReader (ImageWriter writer)
{
  if (writer == null)
    throw new IllegalArgumentException ("null argument");

  ImageWriterSpi spi = writer.getOriginatingProvider();

  String[] readerSpiNames = spi.getImageReaderSpiNames();

  ImageReader r = null;

  if (readerSpiNames != null)
    {
      try
        {
          Class readerClass = Class.forName (readerSpiNames[0]);
          r = (ImageReader) readerClass.newInstance ();
        }
      catch (Exception e)
        {
          return null;
        }
    }
  return r;
}