static Method[] getOverridableMethods(Class c) {
ArrayList<Method> list = new ArrayList<Method>();
HashSet<String> skip = new HashSet<String>();
while (c != null) {
Method[] methods = c.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
String methodKey =
methods[i].getName() + getMethodSignature(methods[i], methods[i].getParameterTypes());
if (skip.contains(methodKey)) continue; // skip this method
int mods = methods[i].getModifiers();
if (Modifier.isStatic(mods)) continue;
if (Modifier.isFinal(mods)) {
// Make sure we don't add a final method to the list
// of overridable methods.
skip.add(methodKey);
continue;
}
if (Modifier.isPublic(mods) || Modifier.isProtected(mods)) {
list.add(methods[i]);
skip.add(methodKey);
}
}
c = c.getSuperclass();
}
return list.toArray(new Method[list.size()]);
}
static Method[] getOverridableMethods(Class c) {
ArrayList list = new ArrayList();
while (c != null) {
Method[] methods = c.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
int mods = methods[i].getModifiers();
if (Modifier.isStatic(mods) || Modifier.isFinal(mods)) continue;
if (Modifier.isPublic(mods) || Modifier.isProtected(mods)) list.add(methods[i]);
}
c = c.getSuperclass();
}
return (Method[]) list.toArray(new Method[list.size()]);
}
private static void appendOverridableMethods(
Class<?> c, ArrayList<Method> list, HashSet<String> skip) {
Method[] methods = c.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
String methodKey =
methods[i].getName() + getMethodSignature(methods[i], methods[i].getParameterTypes());
if (skip.contains(methodKey)) continue; // skip this method
int mods = methods[i].getModifiers();
if (Modifier.isStatic(mods)) continue;
if (Modifier.isFinal(mods)) {
// Make sure we don't add a final method to the list
// of overridable methods.
skip.add(methodKey);
continue;
}
if (Modifier.isPublic(mods) || Modifier.isProtected(mods)) {
list.add(methods[i]);
skip.add(methodKey);
}
}
}
/** Calculates a MD5 digest of the class. */
public String getDigest() {
try {
if (_className == null || "".equals(_className)) return "";
DynamicClassLoader loader =
(DynamicClassLoader) Thread.currentThread().getContextClassLoader();
ClassLoader tmpLoader = loader.getNewTempClassLoader();
Class cl = Class.forName(_className, false, tmpLoader);
if (cl == null) return "";
MessageDigest digest = MessageDigest.getInstance("MD5");
addDigest(digest, cl.getName());
addDigest(digest, cl.getModifiers());
Class superClass = cl.getSuperclass();
if (superClass != null) addDigest(digest, superClass.getName());
Class[] interfaces = cl.getInterfaces();
for (int i = 0; i < interfaces.length; i++) addDigest(digest, interfaces[i].getName());
Field[] fields = cl.getDeclaredFields();
Arrays.sort(fields, new FieldComparator());
if (_checkFields) {
for (Field field : fields) {
if (Modifier.isPrivate(field.getModifiers()) && !_checkPrivate) continue;
if (Modifier.isProtected(field.getModifiers()) && !_checkProtected) continue;
addDigest(digest, field.getName());
addDigest(digest, field.getModifiers());
addDigest(digest, field.getType().getName());
addDigest(digest, field.getAnnotations());
}
}
Method[] methods = cl.getDeclaredMethods();
Arrays.sort(methods, new MethodComparator());
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
if (Modifier.isPrivate(method.getModifiers()) && !_checkPrivate) continue;
if (Modifier.isProtected(method.getModifiers()) && !_checkProtected) continue;
if (Modifier.isStatic(method.getModifiers()) && !_checkStatic) continue;
addDigest(digest, method.getName());
addDigest(digest, method.getModifiers());
addDigest(digest, method.getName());
Class[] param = method.getParameterTypes();
for (int j = 0; j < param.length; j++) addDigest(digest, param[j].getName());
addDigest(digest, method.getReturnType().getName());
Class[] exn = method.getExceptionTypes();
for (int j = 0; j < exn.length; j++) addDigest(digest, exn[j].getName());
addDigest(digest, method.getAnnotations());
}
byte[] digestBytes = new byte[256];
int len = digest.digest(digestBytes, 0, digestBytes.length);
return digestToBase64(digestBytes, len);
} catch (Exception e) {
log.log(Level.FINER, e.toString(), e);
return "";
}
}
private static void discoverAccessibleMethods(
Class<?> clazz,
Map<MethodSignature, Method> map,
boolean includeProtected,
boolean includePrivate) {
if (Modifier.isPublic(clazz.getModifiers()) || includePrivate) {
try {
if (includeProtected || includePrivate) {
while (clazz != null) {
try {
Method[] methods = clazz.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
int mods = method.getModifiers();
if (Modifier.isPublic(mods) || Modifier.isProtected(mods) || includePrivate) {
if (includePrivate) method.setAccessible(true);
map.put(new MethodSignature(method), method);
}
}
clazz = clazz.getSuperclass();
} catch (SecurityException e) {
// Some security settings (i.e., applets) disallow
// access to Class.getDeclaredMethods. Fall back to
// Class.getMethods.
Method[] methods = clazz.getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
MethodSignature sig = new MethodSignature(method);
if (map.get(sig) == null) map.put(sig, method);
}
break; // getMethods gets superclass methods, no
// need to loop any more
}
}
} else {
Method[] methods = clazz.getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
MethodSignature sig = new MethodSignature(method);
map.put(sig, method);
}
}
return;
} catch (SecurityException e) {
Context.reportWarning(
"Could not discover accessible methods of class "
+ clazz.getName()
+ " due to lack of privileges, "
+ "attemping superclasses/interfaces.");
// Fall through and attempt to discover superclass/interface
// methods
}
}
Class<?>[] interfaces = clazz.getInterfaces();
for (int i = 0; i < interfaces.length; i++) {
discoverAccessibleMethods(interfaces[i], map, includeProtected, includePrivate);
}
Class<?> superclass = clazz.getSuperclass();
if (superclass != null) {
discoverAccessibleMethods(superclass, map, includeProtected, includePrivate);
}
}