com.sun.tools.rngdatatype.helpers.DatatypeLibraryLoader Maven / Gradle / Ivy
/*
* Copyright (c) 2022 Eclipse Foundation
* 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 com.sun.tools.rngdatatype.helpers;
import com.sun.tools.rngdatatype.DatatypeLibrary;
import com.sun.tools.rngdatatype.DatatypeLibraryFactory;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.NoSuchElementException;
import java.util.Vector;
/**
* Discovers the datatype library implementation from the classpath.
*
*
* 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);
/**
* Default constructor.
*/
public DatatypeLibraryLoader() {}
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.getConstructor().newInstance();
if (serviceClass.isInstance(obj)) {
providers.addElement(obj);
return true;
}
}
catch (ReflectiveOperationException | 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;
r = new InputStreamReader(in, StandardCharsets.UTF_8);
r = new BufferedReader(r);
Vector tokens = new Vector();
StringBuilder tokenBuf = new StringBuilder();
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;
}
}
}
}