< prev index next >
src/java.xml/share/classes/com/sun/org/apache/bcel/internal/util/SyntheticRepository.java
Print this page
*** 1,8 ****
/*
! * reserved comment block
! * DO NOT REMOVE OR ALTER!
*/
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
--- 1,7 ----
/*
! * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
*/
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
*** 16,60 ****
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
package com.sun.org.apache.bcel.internal.util;
! import java.io.*;
!
import java.util.HashMap;
!
! import com.sun.org.apache.bcel.internal.classfile.*;
/**
! * This repository is used in situations where a Class is created
! * outside the realm of a ClassLoader. Classes are loaded from
! * the file systems using the paths specified in the given
! * class path. By default, this is the value returned by
! * ClassPath.getClassPath().
! * <br>
! * It is designed to be used as a singleton, however it
! * can also be used with custom classpaths.
! *
! /**
! * Abstract definition of a class repository. Instances may be used
! * to load classes from different sources and may be used in the
! * Repository.setRepository method.
*
* @see com.sun.org.apache.bcel.internal.Repository
*
! * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
! * @author David Dixon-Peugh
*/
public class SyntheticRepository implements Repository {
! private static HashMap _instances = new HashMap(); // CLASSPATH X REPOSITORY
!
! private HashMap _loadedClasses = new HashMap(); // CLASSNAME X JAVACLASS
private SyntheticRepository() {
}
public static SyntheticRepository getInstance() {
--- 15,53 ----
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.sun.org.apache.bcel.internal.util;
+ import java.io.IOException;
+ import java.io.InputStream;
! import com.sun.org.apache.bcel.internal.classfile.ClassParser;
! import com.sun.org.apache.bcel.internal.classfile.JavaClass;
! import java.lang.ref.SoftReference;
import java.util.HashMap;
! import java.util.Map;
/**
! * This repository is used in situations where a Class is created outside the
! * realm of a ClassLoader. Classes are loaded from the file systems using the
! * paths specified in the given class path. By default, this is the value
! * returned by ClassPath.getClassPath(). <br>
! * This repository uses a factory design, allowing it to maintain a collection
! * of different classpaths, and as such It is designed to be used as a singleton
! * per classpath.
*
* @see com.sun.org.apache.bcel.internal.Repository
*
! * @version $Id: SyntheticRepository.java 1748124 2016-06-13 08:02:16Z ggregory
! * $
*/
public class SyntheticRepository implements Repository {
! // CLASSNAME X JAVACLASS
! private final Map<String, SoftReference<JavaClass>> loadedClasses = new HashMap<>();
private SyntheticRepository() {
}
public static SyntheticRepository getInstance() {
*** 62,153 ****
}
/**
* Store a new JavaClass instance into this Repository.
*/
! public void storeClass(JavaClass clazz) {
! _loadedClasses.put(clazz.getClassName(), clazz);
clazz.setRepository(this);
}
/**
* Remove class from repository
*/
! public void removeClass(JavaClass clazz) {
! _loadedClasses.remove(clazz.getClassName());
}
/**
* Find an already defined (cached) JavaClass object by name.
*/
! public JavaClass findClass(String className) {
! return (JavaClass)_loadedClasses.get(className);
}
/**
! * Load a JavaClass object for the given class name using
! * the CLASSPATH environment variable.
! */
! public JavaClass loadClass(String className)
! throws ClassNotFoundException
! {
! if(className == null || className.equals("")) {
throw new IllegalArgumentException("Invalid class name " + className);
}
-
className = className.replace('/', '.'); // Just in case, canonical form
IOException e = new IOException("Couldn't find: " + className + ".class");
throw new ClassNotFoundException("Exception while looking for class " +
! className + ": " + e.toString());
}
/**
! * Try to find class source via getResourceAsStream().
* @see Class
* @return JavaClass object for given runtime class
*/
! public JavaClass loadClass(Class clazz) throws ClassNotFoundException {
! String className = clazz.getName();
String name = className;
! int i = name.lastIndexOf('.');
!
! if(i > 0) {
name = name.substring(i + 1);
}
!
! return loadClass(clazz.getResourceAsStream(name + ".class"), className);
}
- private JavaClass loadClass(InputStream is, String className)
- throws ClassNotFoundException
- {
- JavaClass clazz = findClass(className);
-
- if(clazz != null) {
- return clazz;
}
- try {
- if(is != null) {
- ClassParser parser = new ClassParser(is, className);
- clazz = parser.parse();
storeClass(clazz);
-
return clazz;
}
! } catch(IOException e) {
! throw new ClassNotFoundException("Exception while looking for class " +
! className + ": " + e.toString());
}
!
! throw new ClassNotFoundException("SyntheticRepository could not load " +
! className);
}
! /** Clear all entries from cache.
*/
public void clear() {
! _loadedClasses.clear();
}
}
--- 55,177 ----
}
/**
* Store a new JavaClass instance into this Repository.
*/
! @Override
! public void storeClass(final JavaClass clazz) {
! loadedClasses.put(clazz.getClassName(), new SoftReference<>(clazz));
clazz.setRepository(this);
}
/**
* Remove class from repository
*/
! @Override
! public void removeClass(final JavaClass clazz) {
! loadedClasses.remove(clazz.getClassName());
}
/**
* Find an already defined (cached) JavaClass object by name.
*/
! @Override
! public JavaClass findClass(final String className) {
! final SoftReference<JavaClass> ref = loadedClasses.get(className);
! if (ref == null) {
! return null;
! }
! return ref.get();
}
/**
! * Finds a JavaClass object by name. If it is already in this Repository, the
! * Repository version is returned.
! *
! * @param className the name of the class
! * @return the JavaClass object
! * @throws ClassNotFoundException if the class is not in the Repository
! */
! @Override
! public JavaClass loadClass(String className) throws ClassNotFoundException {
! if ((className == null) || className.isEmpty()) {
throw new IllegalArgumentException("Invalid class name " + className);
}
className = className.replace('/', '.'); // Just in case, canonical form
+ final JavaClass clazz = findClass(className);
+ if (clazz != null) {
+ return clazz;
+ }
IOException e = new IOException("Couldn't find: " + className + ".class");
throw new ClassNotFoundException("Exception while looking for class " +
! className + ": " + e, e);
}
/**
! * Find the JavaClass object for a runtime Class object. If a class with the
! * same name is already in this Repository, the Repository version is
! * returned. Otherwise, getResourceAsStream() is called on the Class object
! * to find the class's representation. If the representation is found, it is
! * added to the Repository.
! *
* @see Class
+ * @param clazz the runtime Class object
* @return JavaClass object for given runtime class
+ * @throws ClassNotFoundException if the class is not in the Repository, and
+ * its representation could not be found
*/
! @Override
! public JavaClass loadClass(final Class<?> clazz) throws ClassNotFoundException {
! final String className = clazz.getName();
! final JavaClass repositoryClass = findClass(className);
! if (repositoryClass != null) {
! return repositoryClass;
! }
String name = className;
! final int i = name.lastIndexOf('.');
! if (i > 0) {
name = name.substring(i + 1);
}
! JavaClass cls = null;
! try (InputStream clsStream = clazz.getResourceAsStream(name + ".class")) {
! return cls = loadClass(clsStream, className);
! } catch (final IOException e) {
! return cls;
}
}
+ private JavaClass loadClass(final InputStream is, final String className)
+ throws ClassNotFoundException {
+ try {
+ if (is != null) {
+ final ClassParser parser = new ClassParser(is, className);
+ final JavaClass clazz = parser.parse();
storeClass(clazz);
return clazz;
}
! } catch (final IOException e) {
! throw new ClassNotFoundException("Exception while looking for class "
! + className + ": " + e, e);
! } finally {
! if (is != null) {
! try {
! is.close();
! } catch (final IOException e) {
! // ignored
}
! }
! }
! throw new ClassNotFoundException("SyntheticRepository could not load "
! + className);
}
! /**
! * Clear all entries from cache.
*/
+ @Override
public void clear() {
! loadedClasses.clear();
}
}
< prev index next >