| gvSIG desktop 1

import java.util.HashSet;

import java.util.Set;

import javax.xml.parsers.SAXParserFactory;

 * API entry point to create parsers and writers based on MIME-Type identification.

 * <p>

 * This factory uses a SPI (Service Provider Interface) mechanism to look up for {@link GPEParser}

 * and {@link IGPEWriterHandlerImplementor} implementations that can deal with a requested

 * MIME-Type.

 * </p>

 * <h2>Implementation Lookup</h2>

 * <p>

 * The SPI mechanism keeps parser implementations decoupled from client applications allowing the

 * transparent interchange of implementation, thus defining a format plugin system.

 * </p>

 * <p>

 * Parser and Writer implementations registers themselves lazily by providing a small configuration

 * file bundled together with the rest of the implementation resources. This configuration file

 * consist of a text file at a specific location and with an specific file name, this factory look

 * up mechanism will search for in order to find out the implementation class names.

 * </p>

 * <p>

 * To register a GPEParser implememntation, a file named <code>org.gvsig.gpe.parser.GPEParser</code>

 * shall exist in the class path (hence the ability to have multiple files equally namded budled in

 * different jar files), in the implementation's <code>META-INF/services</code> folder.

 * </p>

 * <p>

 * To register a Writer handler implementation, the same approach shall be followed with a file

 * named <code>META-INF/services/org.gvsig.gpe.writer.IGPEWriterHandlerImplementor</code>

 * </p>

 * <p>

 * The content of both files for a given implementation consists of full qualified class names, one

 * per line. For example, an hypotetical <code>MyFormatParser</code> in the package

 * <code>org.mycompany.gpe</code> and bundled in a jar file called <code>myformat.jar</code>

 * shall provide the following resources:

 * 

 * <pre>

 * <code>

 * $jar tvf myformat.jar

 * META-INF/services/org.gvsig.gpe.parser.GPEParser

 * org/mycompany/gpe/MyFormatParser.class

 * </code>

 * </pre>

 * 

 * And the content of the file <code>META-INF/services/org.gvsig.gpe.parser.GPEParser</code> shall

 * be a single line of text with the <code>org.mycompany.gpe.MyFormatParser</code> class name.

 * 

    /**

     * Looks up the available parser implementations and returns the list of supported MIME-Type

     * identifiers.

     * 

     * @return the list of available parsing MIME types

     */

//    public static Set getAvailableParserTypes() {

//        Set mimeTypes = new HashSet();

//        Iterator availableParsers = availableParsers();

//        while(availableParsers.hasNext()){

//            GPEParser parser = (GPEParser) availableParsers.next();

//            mimeTypes.add(parser.getMimeType());

//        }

//        return mimeTypes;

//    }

//

//    public static Set getAvailableWriterTypes() {

//        throw new UnsupportedOperationException();

//    }

    /**

     * Returns an iterator over instances of the registered parsers.

     * <p>

     * NOTE: since GPEParser is an abstract and statefull class rather than an interface, this

     * method shall stay private in order to ensure we return a new instance for the required format

     * every time.

     * </p>

     * 

     * @return all the registered parsers

     */

    private static Iterator availableParsers() {

        Iterator providers = sun.misc.Service.providers(GPEParser.class);

        return providers;

    }

    /**

     * Returns an iterator over instances of the registered writers.

     * <p>

     * NOTE: since GPEWriter is an abstract and statefull class rather than an interface, this

     * method shall stay private in order to ensure we return a new instance for the required format

     * every time.

     * </p>

     * 

     * @return all the registered writers

     */

    private static Iterator availableWriters() {

        Iterator providers = sun.misc.Service.providers(IGPEWriterHandlerImplementor.class);

        return providers;

    }

    public static GPEParser createParserByClass(String prefferredImplClassName) {

        Class prefferredImplClass = null;

        try {

            prefferredImplClass = Class.forName(prefferredImplClassName);

        } catch (ClassNotFoundException e) {

            return null;

        }

        Iterator providers = availableParsers();

        while (providers.hasNext()) {

            GPEParser next = (GPEParser) providers.next();

            if (prefferredImplClass.isInstance(next)) {

                return next;

            }

        }

        return null;

    }

    /**

     * Create a new parser from a name

     * 

     * @param name GPEParser name

     * @param contenHandler Application contenHandler usett to throw the parsing events

     * @param errorHandler Application errror handler used to put errors and warnings

     * @throws GPEParserCreationException

     */

    public static GPEParser createParser(String name) throws GPEParserCreationException {

        Iterator providers = availableParsers();

        if (providers.hasNext()) {

            GPEParser parser = (GPEParser) providers.next();

            if (parser.getName().compareTo(name) == 0) {

                return parser;

            }

        }

        return null;

    }

    /**

     * Gets the parser that can open the file (if it exists)

     * 

     * @param uri File to open

     * @return Null if the driver doesn't exist

     * @throws GPEParserCreationException

     * @throws SecurityException

     * @throws IllegalArgumentException

     */

    public static GPEParser createParser(URI uri) throws GPEParserCreationException {

        Iterator providers = availableParsers();

        if (providers.hasNext()) {

            GPEParser parser = (GPEParser) providers.next();

            if (parser.accept(uri)) {

                return parser;

            }

        }

        return null;

    }

    /**

     * Create a new content writer from a name

     * 

     * @param name GPEWriterHandler name GPEParser name

     * @param contenHandler Application contenHandler usett to throw the parsing events

     * @param errorHandler Application errror handler used to put errors and warnings

     * @throws GPEWriterHandlerCreationException

     */

    public static GPEWriterHandler createWriter(String name)

            throws GPEWriterHandlerCreationException {

        Iterator providers = availableWriters();

        if (providers.hasNext()) {

            IGPEWriterHandlerImplementor implementor = (IGPEWriterHandlerImplementor) providers

                    .next();

            if (implementor.getName().compareTo(name) == 0) {

                new GPEWriterHandler(implementor);

            }

        }

        return null;

    }

    public static GPEWriterHandler createWriterByClass(String prefferredImplClassName) {

            IGPEWriterHandlerImplementor next = (IGPEWriterHandlerImplementor) providers.next();

        }

    /**

     * Gets all the writers that can

     * 

     * @param format

     * @return

     */

    public static ArrayList getWriterHandlerByFormat(String format) {

        Iterator providers = availableWriters();

        ArrayList possibleWriters = new ArrayList();

        if (providers.hasNext()) {

            IGPEWriterHandlerImplementor implementor = (IGPEWriterHandlerImplementor) providers

                    .next();

            String[] formats = implementor.getFormats();

            for (int i = 0; i < formats.length; i++) {

                if (formats[i].toLowerCase().compareTo(format.toLowerCase()) == 0) {

                    possibleWriters.add(new GPEWriterHandler(implementor));

                }

            }

        }

        return possibleWriters;

    }

    /**

     * Return true if exists a driver that can open the file

     * 

     * @param uri File to open

     * @return true if the driver exists

     */

    public static boolean accept(URI uri) {

        Iterator providers = availableParsers();

        if (providers.hasNext()) {

            GPEParser parser = (GPEParser) providers.next();

            if (parser.accept(uri)) {

                return true;

            }

        }

        return false;

    }