/**
* Creates a new public interface. If there already exists a class/interface with the same name,
* the new interface overwrites that previous one.
*
* @param name a fully-qualified interface name.
* @param superclass the super interface.
* @throws RuntimeException if the existing interface is frozen.
*/
public synchronized CtClass makeInterface(String name, CtClass superclass)
throws RuntimeException {
checkNotFrozen(name);
CtClass clazz = new CtNewClass(name, this, true, superclass);
cacheCtClass(name, clazz, true);
return clazz;
}
/**
* Creates a new public class. If there already exists a class/interface with the same name, the
* new class overwrites that previous class.
*
* <p>If no constructor is explicitly added to the created new class, Javassist generates
* constructors and adds it when the class file is generated. It generates a new constructor for
* each constructor of the super class. The new constructor takes the same set of parameters and
* invokes the corresponding constructor of the super class. All the received parameters are
* passed to it.
*
* @param classname a fully-qualified class name.
* @param superclass the super class.
* @throws RuntimeException if the existing class is frozen.
*/
public synchronized CtClass makeClass(String classname, CtClass superclass)
throws RuntimeException {
checkNotFrozen(classname);
CtClass clazz = new CtNewClass(classname, this, false, superclass);
cacheCtClass(classname, clazz, true);
return clazz;
}
@Override
protected void cacheCtClass(String className, CtClass c, boolean dynamic) {
if (isSrg && !exclude(className)) {
return;
}
super.cacheCtClass(className, c, dynamic);
}
/*
* This method is invoked by CtClassType.setName(). It removes a
* CtClass object from the hash table and inserts it with the new
* name. Don't delegate to the parent.
*/
synchronized void classNameChanged(String oldname, CtClass clazz) {
CtClass c = (CtClass) getCached(oldname);
if (c == clazz) // must check this equation.
removeCached(oldname); // see getAndRename().
String newName = clazz.getName();
checkNotFrozen(newName);
cacheCtClass(newName, clazz, false);
}
/**
* Creates a new class (or interface) from the given class file. If there already exists a class
* with the same name, the new class overwrites that previous class.
*
* <p>This method is used for creating a <code>CtClass</code> object directly from a class file.
* The qualified class name is obtained from the class file; you do not have to explicitly give
* the name.
*
* @param classfile class file.
* @param ifNotFrozen throws a RuntimeException if this parameter is true and there is a frozen
* class with the same name.
* @see javassist.ByteArrayClassPath
*/
public CtClass makeClass(InputStream classfile, boolean ifNotFrozen)
throws IOException, RuntimeException {
compress();
classfile = new BufferedInputStream(classfile);
CtClass clazz = new CtClassType(classfile, this);
clazz.checkModify();
String classname = clazz.getName();
if (ifNotFrozen) checkNotFrozen(classname);
cacheCtClass(classname, clazz, true);
return clazz;
}
/**
* Creates a new class (or interface) from the given class file. If there already exists a class
* with the same name, this method returns the existing class; a new class is never created from
* the given class file.
*
* <p>This method is used for creating a <code>CtClass</code> object directly from a class file.
* The qualified class name is obtained from the class file; you do not have to explicitly give
* the name.
*
* @param classfile the class file.
* @see #makeClass(InputStream)
* @see javassist.ByteArrayClassPath
* @since 3.9
*/
public CtClass makeClassIfNew(InputStream classfile) throws IOException, RuntimeException {
compress();
classfile = new BufferedInputStream(classfile);
CtClass clazz = new CtClassType(classfile, this);
clazz.checkModify();
String classname = clazz.getName();
CtClass found = checkNotExists(classname);
if (found != null) return found;
else {
cacheCtClass(classname, clazz, true);
return clazz;
}
}
/**
* @param useCache false if the cached CtClass must be ignored.
* @param searchParent false if the parent class pool is not searched.
* @return null if the class could not be found.
*/
protected synchronized CtClass get0(String classname, boolean useCache) throws NotFoundException {
CtClass clazz = null;
if (useCache) {
clazz = getCached(classname);
if (clazz != null) return clazz;
}
if (!childFirstLookup && parent != null) {
clazz = parent.get0(classname, useCache);
if (clazz != null) return clazz;
}
clazz = createCtClass(classname, useCache);
if (clazz != null) {
// clazz.getName() != classname if classname is "[L<name>;".
if (useCache) cacheCtClass(clazz.getName(), clazz, false);
return clazz;
}
if (childFirstLookup && parent != null) clazz = parent.get0(classname, useCache);
return clazz;
}
/**
* Creates a new public nested class. This method is called by CtClassType.makeNestedClass().
*
* @param classname a fully-qualified class name.
* @return the nested class.
*/
synchronized CtClass makeNestedClass(String classname) {
checkNotFrozen(classname);
CtClass clazz = new CtNewNestedClass(classname, this, false, null);
cacheCtClass(classname, clazz, true);
return clazz;
}