Subversion Repositories openrisc

/**

 * Copyright (c) 2001, Thai Open Source Software Center Ltd

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are

 * met:

 *

 *     Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *

 *     Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in

 *     the documentation and/or other materials provided with the

 *     distribution.

 *

 *     Neither the name of the Thai Open Source Software Center Ltd nor

 *     the names of its contributors may be used to endorse or promote

 *     products derived from this software without specific prior written

 *     permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package org.relaxng.datatype.helpers;

import org.relaxng.datatype.DatatypeLibraryFactory;

import org.relaxng.datatype.DatatypeLibrary;

import java.util.Enumeration;

import java.util.NoSuchElementException;

import java.util.Vector;

import java.io.Reader;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import java.net.URL;

/**

 * Discovers the datatype library implementation from the classpath.

 *

 * <p>

 * The call of the createDatatypeLibrary method finds an implementation

 * from a given datatype library URI at run-time.

 */

public class DatatypeLibraryLoader implements DatatypeLibraryFactory {

  private final Service service = new Service(DatatypeLibraryFactory.class);

  public DatatypeLibrary createDatatypeLibrary(String uri) {

    for (Enumeration e = service.getProviders();

         e.hasMoreElements();) {

      DatatypeLibraryFactory factory

        = (DatatypeLibraryFactory)e.nextElement();

      DatatypeLibrary library = factory.createDatatypeLibrary(uri);

      if (library != null)

        return library;

    }

    return null;

  }

        private static class Service {

          private final Class serviceClass;

          private final Enumeration configFiles;

          private Enumeration classNames = null;

          private final Vector providers = new Vector();

          private Loader loader;

          private class ProviderEnumeration implements Enumeration {

            private int nextIndex = 0;

            public boolean hasMoreElements() {

              return nextIndex < providers.size() || moreProviders();

            }

            public Object nextElement() {

              try {

                return providers.elementAt(nextIndex++);

              }

              catch (ArrayIndexOutOfBoundsException e) {

                throw new NoSuchElementException();

              }

            }

          }

          private static class Singleton implements Enumeration {

            private Object obj;

            private Singleton(Object obj) {

              this.obj = obj;

            }

            public boolean hasMoreElements() {

              return obj != null;

            }

            public Object nextElement() {

              if (obj == null)

                throw new NoSuchElementException();

              Object tem = obj;

              obj = null;

              return tem;

            }

          }

          // JDK 1.1

          private static class Loader {

            Enumeration getResources(String resName) {

              ClassLoader cl = Loader.class.getClassLoader();

              URL url;

              if (cl == null)

                url = ClassLoader.getSystemResource(resName);

              else

                url = cl.getResource(resName);

              return new Singleton(url);

            }

            Class loadClass(String name) throws ClassNotFoundException {

              return Class.forName(name);

            }

          }

          // JDK 1.2+

          private static class Loader2 extends Loader {

            private ClassLoader cl;

            Loader2() {

              cl = Loader2.class.getClassLoader();

              // If the thread context class loader has the class loader

              // of this class as an ancestor, use the thread context class

              // loader.  Otherwise, the thread context class loader

              // probably hasn't been set up properly, so don't use it.

              ClassLoader clt = Thread.currentThread().getContextClassLoader();

              for (ClassLoader tem = clt; tem != null; tem = tem.getParent())

                if (tem == cl) {

                  cl = clt;

                  break;

                }

            }

            Enumeration getResources(String resName) {

              try {

                return cl.getResources(resName);

              }

              catch (IOException e) {

                return new Singleton(null);

              }

            }

            Class loadClass(String name) throws ClassNotFoundException {

              return Class.forName(name, true, cl);

            }

          }

          public Service(Class cls) {

            try {

              loader = new Loader2();

            }

            catch (NoSuchMethodError e) {

              loader = new Loader();

            }

            serviceClass = cls;

            String resName = "META-INF/services/" + serviceClass.getName();

            configFiles = loader.getResources(resName);

          }

          public Enumeration getProviders() {

            return new ProviderEnumeration();

          }

          synchronized private boolean moreProviders() {

            for (;;) {

              while (classNames == null) {

                if (!configFiles.hasMoreElements())

                  return false;

                classNames = parseConfigFile((URL)configFiles.nextElement());

              }

              while (classNames.hasMoreElements()) {

                String className = (String)classNames.nextElement();

                try {

                  Class cls = loader.loadClass(className);

                  Object obj = cls.newInstance();

                  if (serviceClass.isInstance(obj)) {

                    providers.addElement(obj);

                    return true;

                  }

                }

                catch (ClassNotFoundException e) { }

                catch (InstantiationException e) { }

                catch (IllegalAccessException e) { }

                catch (LinkageError e) { }

              }

              classNames = null;

            }

          }

          private static final int START = 0;

          private static final int IN_NAME = 1;

          private static final int IN_COMMENT = 2;

          private static Enumeration parseConfigFile(URL url) {

            try {

              InputStream in = url.openStream();

              Reader r;

              try {

                r = new InputStreamReader(in, "UTF-8");

              }

              catch (UnsupportedEncodingException e) {

                r = new InputStreamReader(in, "UTF8");

              }

              r = new BufferedReader(r);

              Vector tokens = new Vector();

              StringBuffer tokenBuf = new StringBuffer();

              int state = START;

              for (;;) {

                int n = r.read();

                if (n < 0)

                  break;

                char c = (char)n;

                switch (c) {

                case '\r':

                case '\n':

                  state = START;

                  break;

                case ' ':

                case '\t':

                  break;

                case '#':

                  state = IN_COMMENT;

                  break;

                default:

                  if (state != IN_COMMENT) {

                    state = IN_NAME;

                    tokenBuf.append(c);

                  }

                  break;

                }

                if (tokenBuf.length() != 0 && state != IN_NAME) {

                  tokens.addElement(tokenBuf.toString());

                  tokenBuf.setLength(0);

                }

              }

              if (tokenBuf.length() != 0)

                tokens.addElement(tokenBuf.toString());

              return tokens.elements();

            }

            catch (IOException e) {

              return null;

            }

          }

        }

}