--- a/jdk/src/share/classes/java/lang/Class.java Mon Mar 10 14:32:51 2008 -0700
+++ b/jdk/src/share/classes/java/lang/Class.java Mon Mar 10 15:07:09 2008 -0700
@@ -345,9 +345,9 @@
// since we have to do the security check here anyway
// (the stack depth is wrong for the Constructor's
// security check to work)
- java.security.AccessController.doPrivileged
- (new java.security.PrivilegedAction() {
- public Object run() {
+ java.security.AccessController.doPrivileged(
+ new java.security.PrivilegedAction<Void>() {
+ public Void run() {
c.setAccessible(true);
return null;
}
@@ -1302,10 +1302,10 @@
// out anything other than public members and (2) public member access
// has already been ok'd by the SecurityManager.
- Class[] result = (Class[]) java.security.AccessController.doPrivileged
- (new java.security.PrivilegedAction() {
- public Object run() {
- java.util.List<Class> list = new java.util.ArrayList();
+ return java.security.AccessController.doPrivileged(
+ new java.security.PrivilegedAction<Class[]>() {
+ public Class[] run() {
+ List<Class> list = new ArrayList<Class>();
Class currentClass = Class.this;
while (currentClass != null) {
Class[] members = currentClass.getDeclaredClasses();
@@ -1316,12 +1316,9 @@
}
currentClass = currentClass.getSuperclass();
}
- Class[] empty = {};
- return list.toArray(empty);
+ return list.toArray(new Class[0]);
}
});
-
- return result;
}
@@ -2215,15 +2212,15 @@
// Caches for certain reflective results
private static boolean useCaches = true;
- private volatile transient SoftReference declaredFields;
- private volatile transient SoftReference publicFields;
- private volatile transient SoftReference declaredMethods;
- private volatile transient SoftReference publicMethods;
- private volatile transient SoftReference declaredConstructors;
- private volatile transient SoftReference publicConstructors;
+ private volatile transient SoftReference<Field[]> declaredFields;
+ private volatile transient SoftReference<Field[]> publicFields;
+ private volatile transient SoftReference<Method[]> declaredMethods;
+ private volatile transient SoftReference<Method[]> publicMethods;
+ private volatile transient SoftReference<Constructor<T>[]> declaredConstructors;
+ private volatile transient SoftReference<Constructor<T>[]> publicConstructors;
// Intermediate results for getFields and getMethods
- private volatile transient SoftReference declaredPublicFields;
- private volatile transient SoftReference declaredPublicMethods;
+ private volatile transient SoftReference<Field[]> declaredPublicFields;
+ private volatile transient SoftReference<Method[]> declaredPublicMethods;
// Incremented by the VM on each call to JVM TI RedefineClasses()
// that redefines this class or a superclass.
@@ -2295,11 +2292,11 @@
clearCachesOnClassRedefinition();
if (publicOnly) {
if (declaredPublicFields != null) {
- res = (Field[]) declaredPublicFields.get();
+ res = declaredPublicFields.get();
}
} else {
if (declaredFields != null) {
- res = (Field[]) declaredFields.get();
+ res = declaredFields.get();
}
}
if (res != null) return res;
@@ -2308,9 +2305,9 @@
res = Reflection.filterFields(this, getDeclaredFields0(publicOnly));
if (useCaches) {
if (publicOnly) {
- declaredPublicFields = new SoftReference(res);
+ declaredPublicFields = new SoftReference<Field[]>(res);
} else {
- declaredFields = new SoftReference(res);
+ declaredFields = new SoftReference<Field[]>(res);
}
}
return res;
@@ -2319,22 +2316,22 @@
// Returns an array of "root" fields. These Field objects must NOT
// be propagated to the outside world, but must instead be copied
// via ReflectionFactory.copyField.
- private Field[] privateGetPublicFields(Set traversedInterfaces) {
+ private Field[] privateGetPublicFields(Set<Class<?>> traversedInterfaces) {
checkInitted();
Field[] res = null;
if (useCaches) {
clearCachesOnClassRedefinition();
if (publicFields != null) {
- res = (Field[]) publicFields.get();
+ res = publicFields.get();
}
if (res != null) return res;
}
// No cached value available; compute value recursively.
// Traverse in correct order for getField().
- List fields = new ArrayList();
+ List<Field> fields = new ArrayList<Field>();
if (traversedInterfaces == null) {
- traversedInterfaces = new HashSet();
+ traversedInterfaces = new HashSet<Class<?>>();
}
// Local fields
@@ -2342,9 +2339,7 @@
addAll(fields, tmp);
// Direct superinterfaces, recursively
- Class[] interfaces = getInterfaces();
- for (int i = 0; i < interfaces.length; i++) {
- Class c = interfaces[i];
+ for (Class<?> c : getInterfaces()) {
if (!traversedInterfaces.contains(c)) {
traversedInterfaces.add(c);
addAll(fields, c.privateGetPublicFields(traversedInterfaces));
@@ -2353,7 +2348,7 @@
// Direct superclass, recursively
if (!isInterface()) {
- Class c = getSuperclass();
+ Class<?> c = getSuperclass();
if (c != null) {
addAll(fields, c.privateGetPublicFields(traversedInterfaces));
}
@@ -2362,12 +2357,12 @@
res = new Field[fields.size()];
fields.toArray(res);
if (useCaches) {
- publicFields = new SoftReference(res);
+ publicFields = new SoftReference<Field[]>(res);
}
return res;
}
- private static void addAll(Collection c, Field[] o) {
+ private static void addAll(Collection<Field> c, Field[] o) {
for (int i = 0; i < o.length; i++) {
c.add(o[i]);
}
@@ -2383,18 +2378,18 @@
// Returns an array of "root" constructors. These Constructor
// objects must NOT be propagated to the outside world, but must
// instead be copied via ReflectionFactory.copyConstructor.
- private Constructor[] privateGetDeclaredConstructors(boolean publicOnly) {
+ private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
checkInitted();
- Constructor[] res = null;
+ Constructor<T>[] res = null;
if (useCaches) {
clearCachesOnClassRedefinition();
if (publicOnly) {
if (publicConstructors != null) {
- res = (Constructor[]) publicConstructors.get();
+ res = publicConstructors.get();
}
} else {
if (declaredConstructors != null) {
- res = (Constructor[]) declaredConstructors.get();
+ res = declaredConstructors.get();
}
}
if (res != null) return res;
@@ -2407,9 +2402,9 @@
}
if (useCaches) {
if (publicOnly) {
- publicConstructors = new SoftReference(res);
+ publicConstructors = new SoftReference<Constructor<T>[]>(res);
} else {
- declaredConstructors = new SoftReference(res);
+ declaredConstructors = new SoftReference<Constructor<T>[]>(res);
}
}
return res;
@@ -2431,11 +2426,11 @@
clearCachesOnClassRedefinition();
if (publicOnly) {
if (declaredPublicMethods != null) {
- res = (Method[]) declaredPublicMethods.get();
+ res = declaredPublicMethods.get();
}
} else {
if (declaredMethods != null) {
- res = (Method[]) declaredMethods.get();
+ res = declaredMethods.get();
}
}
if (res != null) return res;
@@ -2444,9 +2439,9 @@
res = Reflection.filterMethods(this, getDeclaredMethods0(publicOnly));
if (useCaches) {
if (publicOnly) {
- declaredPublicMethods = new SoftReference(res);
+ declaredPublicMethods = new SoftReference<Method[]>(res);
} else {
- declaredMethods = new SoftReference(res);
+ declaredMethods = new SoftReference<Method[]>(res);
}
}
return res;
@@ -2552,7 +2547,7 @@
if (useCaches) {
clearCachesOnClassRedefinition();
if (publicMethods != null) {
- res = (Method[]) publicMethods.get();
+ res = publicMethods.get();
}
if (res != null) return res;
}
@@ -2602,7 +2597,7 @@
methods.compactAndTrim();
res = methods.getArray();
if (useCaches) {
- publicMethods = new SoftReference(res);
+ publicMethods = new SoftReference<Method[]>(res);
}
return res;
}
@@ -2713,11 +2708,11 @@
private Constructor<T> getConstructor0(Class[] parameterTypes,
int which) throws NoSuchMethodException
{
- Constructor[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
- for (int i = 0; i < constructors.length; i++) {
+ Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
+ for (Constructor<T> constructor : constructors) {
if (arrayContentsEq(parameterTypes,
- constructors[i].getParameterTypes())) {
- return getReflectionFactory().copyConstructor(constructors[i]);
+ constructor.getParameterTypes())) {
+ return getReflectionFactory().copyConstructor(constructor);
}
}
throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
@@ -2767,18 +2762,18 @@
return out;
}
- private static Constructor[] copyConstructors(Constructor[] arg) {
- Constructor[] out = new Constructor[arg.length];
+ private static <U> Constructor<U>[] copyConstructors(Constructor<U>[] arg) {
+ Constructor<U>[] out = arg.clone();
ReflectionFactory fact = getReflectionFactory();
- for (int i = 0; i < arg.length; i++) {
- out[i] = fact.copyConstructor(arg[i]);
+ for (int i = 0; i < out.length; i++) {
+ out[i] = fact.copyConstructor(out[i]);
}
return out;
}
private native Field[] getDeclaredFields0(boolean publicOnly);
private native Method[] getDeclaredMethods0(boolean publicOnly);
- private native Constructor[] getDeclaredConstructors0(boolean publicOnly);
+ private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);
private native Class[] getDeclaredClasses0();
private static String argumentTypesToString(Class[] argTypes) {
@@ -2883,7 +2878,7 @@
// Fetches the factory for reflective objects
private static ReflectionFactory getReflectionFactory() {
if (reflectionFactory == null) {
- reflectionFactory = (ReflectionFactory)
+ reflectionFactory =
java.security.AccessController.doPrivileged
(new sun.reflect.ReflectionFactory.GetReflectionFactoryAction());
}
@@ -2895,8 +2890,8 @@
private static boolean initted = false;
private static void checkInitted() {
if (initted) return;
- AccessController.doPrivileged(new PrivilegedAction() {
- public Object run() {
+ AccessController.doPrivileged(new PrivilegedAction<Void>() {
+ public Void run() {
// Tests to ensure the system properties table is fully
// initialized. This is needed because reflection code is
// called very early in the initialization process (before
@@ -2941,17 +2936,17 @@
/**
* Returns the elements of this enum class or null if this
* Class object does not represent an enum type;
- * identical to getEnumConstantsShared except that
- * the result is uncloned, cached, and shared by all callers.
+ * identical to getEnumConstants except that the result is
+ * uncloned, cached, and shared by all callers.
*/
T[] getEnumConstantsShared() {
if (enumConstants == null) {
if (!isEnum()) return null;
try {
final Method values = getMethod("values");
- java.security.AccessController.doPrivileged
- (new java.security.PrivilegedAction() {
- public Object run() {
+ java.security.AccessController.doPrivileged(
+ new java.security.PrivilegedAction<Void>() {
+ public Void run() {
values.setAccessible(true);
return null;
}