/*
* Copyright 2000-2004 The Apache Software Foundation
*
* 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.bcel;
import java.io.IOException;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.util.ClassPath;
import org.apache.bcel.util.SyntheticRepository;
/**
* The repository maintains informations about class interdependencies, e.g.,
* whether a class is a sub-class of another. Delegates actual class loading
* to SyntheticRepository with current class path by default.
*
* @see org.apache.bcel.util.Repository
* @see org.apache.bcel.util.SyntheticRepository
*
* @version $Id: Repository.java 386056 2006-03-15 11:31:56Z tcurdt $
* @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
*/
public abstract class Repository {
private static org.apache.bcel.util.Repository _repository = SyntheticRepository.getInstance();
/** @return currently used repository instance
*/
public static org.apache.bcel.util.Repository getRepository() {
return _repository;
}
/** Set repository instance to be used for class loading
*/
public static void setRepository( org.apache.bcel.util.Repository rep ) {
_repository = rep;
}
/** Lookup class somewhere found on your CLASSPATH, or whereever the
* repository instance looks for it.
*
* @return class object for given fully qualified class name
* @throws ClassNotFoundException if the class could not be found or
* parsed correctly
*/
public static JavaClass lookupClass( String class_name ) throws ClassNotFoundException {
return _repository.loadClass(class_name);
}
/**
* Try to find class source using the internal repository instance.
* @see Class
* @return JavaClass object for given runtime class
* @throws ClassNotFoundException if the class could not be found or
* parsed correctly
*/
public static JavaClass lookupClass( Class clazz ) throws ClassNotFoundException {
return _repository.loadClass(clazz);
}
/**
* @return class file object for given Java class by looking on the
* system class path; returns null if the class file can't be
* found
*/
public static ClassPath.ClassFile lookupClassFile( String class_name ) {
try {
ClassPath path = _repository.getClassPath();
if (path == null) {
return null;
}
return path.getClassFile(class_name);
} catch (IOException e) {
return null;
}
}
/** Clear the repository.
*/
public static void clearCache() {
_repository.clear();
}
/**
* Add clazz to repository if there isn't an equally named class already in there.
*
* @return old entry in repository
*/
public static JavaClass addClass( JavaClass clazz ) {
JavaClass old = _repository.findClass(clazz.getClassName());
_repository.storeClass(clazz);
return old;
}
/**
* Remove class with given (fully qualified) name from repository.
*/
public static void removeClass( String clazz ) {
_repository.removeClass(_repository.findClass(clazz));
}
/**
* Remove given class from repository.
*/
public static void removeClass( JavaClass clazz ) {
_repository.removeClass(clazz);
}
/**
* @return list of super classes of clazz in ascending order, i.e.,
* Object is always the last element
* @throws ClassNotFoundException if any of the superclasses can't be found
*/
public static JavaClass[] getSuperClasses( JavaClass clazz ) throws ClassNotFoundException {
return clazz.getSuperClasses();
}
/**
* @return list of super classes of clazz in ascending order, i.e.,
* Object is always the last element.
* @throws ClassNotFoundException if the named class or any of its
* superclasses can't be found
*/
public static JavaClass[] getSuperClasses( String class_name ) throws ClassNotFoundException {
JavaClass jc = lookupClass(class_name);
return getSuperClasses(jc);
}
/**
* @return all interfaces implemented by class and its super
* classes and the interfaces that those interfaces extend, and so on.
* (Some people call this a transitive hull).
* @throws ClassNotFoundException if any of the class's
* superclasses or superinterfaces can't be found
*/
public static JavaClass[] getInterfaces( JavaClass clazz ) throws ClassNotFoundException {
return clazz.getAllInterfaces();
}
/**
* @return all interfaces implemented by class and its super
* classes and the interfaces that extend those interfaces, and so on
* @throws ClassNotFoundException if the named class can't be found,
* or if any of its superclasses or superinterfaces can't be found
*/
public static JavaClass[] getInterfaces( String class_name ) throws ClassNotFoundException {
return getInterfaces(lookupClass(class_name));
}
/**
* Equivalent to runtime "instanceof" operator.
* @return true, if clazz is an instance of super_class
* @throws ClassNotFoundException if any superclasses or superinterfaces
* of clazz can't be found
*/
public static boolean instanceOf( JavaClass clazz, JavaClass super_class )
throws ClassNotFoundException {
return clazz.instanceOf(super_class);
}
/**
* @return true, if clazz is an instance of super_class
* @throws ClassNotFoundException if either clazz or super_class
* can't be found
*/
public static boolean instanceOf( String clazz, String super_class )
throws ClassNotFoundException {
return instanceOf(lookupClass(clazz), lookupClass(super_class));
}
/**
* @return true, if clazz is an instance of super_class
* @throws ClassNotFoundException if super_class can't be found
*/
public static boolean instanceOf( JavaClass clazz, String super_class )
throws ClassNotFoundException {
return instanceOf(clazz, lookupClass(super_class));
}
/**
* @return true, if clazz is an instance of super_class
* @throws ClassNotFoundException if clazz can't be found
*/
public static boolean instanceOf( String clazz, JavaClass super_class )
throws ClassNotFoundException {
return instanceOf(lookupClass(clazz), super_class);
}
/**
* @return true, if clazz is an implementation of interface inter
* @throws ClassNotFoundException if any superclasses or superinterfaces
* of clazz can't be found
*/
public static boolean implementationOf( JavaClass clazz, JavaClass inter )
throws ClassNotFoundException {
return clazz.implementationOf(inter);
}
/**
* @return true, if clazz is an implementation of interface inter
* @throws ClassNotFoundException if clazz, inter, or any superclasses
* or superinterfaces of clazz can't be found
*/
public static boolean implementationOf( String clazz, String inter )
throws ClassNotFoundException {
return implementationOf(lookupClass(clazz), lookupClass(inter));
}
/**
* @return true, if clazz is an implementation of interface inter
* @throws ClassNotFoundException if inter or any superclasses
* or superinterfaces of clazz can't be found
*/
public static boolean implementationOf( JavaClass clazz, String inter )
throws ClassNotFoundException {
return implementationOf(clazz, lookupClass(inter));
}
/**
* @return true, if clazz is an implementation of interface inter
* @throws ClassNotFoundException if clazz or any superclasses or
* superinterfaces of clazz can't be found
*/
public static boolean implementationOf( String clazz, JavaClass inter )
throws ClassNotFoundException {
return implementationOf(lookupClass(clazz), inter);
}
}