/*
* Copyright 2005-2006 The Apache Software Foundation or its licensors, as applicable.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* 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 org.apache.harmony.tools;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.util.ClassPath;
/**
* This class locates a class in the given class path with the given name. You
* can use this class to get a JavaClass object which represents the found
* class.
*
* This class depends on Apache Byte Code Engineering Library (BCEL) 5.0 or
* later. Please see http://jakarta.apache.org/bcel for more information
* about this library.
*/
public class ClassProvider {
/**
* Loading class files from a class path.
*/
private ClassPath classpath;
/**
* Verbose output or not.
*/
private boolean verbose;
/**
* Keeps loaded and parsed class files.
*/
private Map cache;
/**
* Constructs a <code>ClassProvider</code> object.
*
* @param bootClasspath - a path that will be prepended to the default
* class path.
* @param classpath - a path that will be apppended to the default class
* path.
* @param verbose - a verbose output.
*/
public ClassProvider(String bootClasspath, String classpath, boolean verbose) {
StringBuffer pathString = new StringBuffer();
// Append the given boot class path, if any.
if (bootClasspath != null) {
pathString.append(bootClasspath).append(File.pathSeparatorChar);
}
// Append the default class path.
pathString.append(getSystemClassPath()).append(File.pathSeparatorChar);
// Append the given class path, if any.
if (classpath != null) {
pathString.append(classpath).append(File.pathSeparatorChar);
}
if (verbose) {
System.out.println("class.path: " + pathString.toString());
}
this.classpath = new ClassPath(pathString.toString());
this.verbose = verbose;
this.cache = new HashMap();
}
/**
* Returns the system class path.
*
* @return the system class path.
*/
private String getSystemClassPath() {
String sep = System.getProperty("path.separator");
StringBuffer cp = new StringBuffer();
for (Enumeration e = System.getProperties().propertyNames(); e.hasMoreElements();) {
// Enumerate all the system properties.
String prop = (String) e.nextElement();
if (prop.endsWith("class.path")) {
// Add the value of a property to the class path, if its
// name ends with "class.path".
cp.append(System.getProperty(prop)).append(sep);
}
}
return cp.toString();
}
/**
* Returns a JavaClass object which represents a class file with the given
* name.
*
* @param name - a fully qualified name of a class.
* @return a JavaClass object which represents a class file with the given
* name.
* @throws ClassNotFoundException if a class file with the given name is
* not found.
*/
public synchronized JavaClass getJavaClass(String name)
throws ClassNotFoundException {
try {
// Try to get the class from the cache.
JavaClass result = (JavaClass) cache.get(name);
// If cache doesn't contain such a class load it from a class path.
if (result == null) {
// Get a file and parse its contents.
ClassPath.ClassFile cf = classpath.getClassFile(name);
InputStream is = cf.getInputStream();
ClassParser parser = new ClassParser(is, cf.getPath());
result = parser.parse();
// Put the parsed class file into the cache.
cache.put(name, result);
if (verbose) {
StringBuffer s = new StringBuffer();
// If we use BCEL 5.1 or later one day we definitely
// should remove the following if and replace
// cf.getPath() with cf.getBase()!
if (!(is instanceof FileInputStream)) {
s.append("class.path:");
}
s.append(cf.getPath());
System.out.println(name + " loaded from " + s);
}
} else {
if (verbose) {
System.out.println(name + " retrieved from a cache");
}
}
return result;
} catch (Exception e) {
throw new ClassNotFoundException(name, e);
}
}
}