public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
checkMemberAccess(Member.DECLARED);
if (!type.isClassType()) throwNoSuchMethodException(name, parameterTypes);
if (name == null) {
throwNoSuchMethodException(name, parameterTypes);
}
Atom aName = Atom.findOrCreateUnicodeAtom(name);
if (aName == RVMClassLoader.StandardClassInitializerMethodName
|| aName == RVMClassLoader.StandardObjectInitializerMethodName) {
// <init> and <clinit> are not methods.
throwNoSuchMethodException(name, parameterTypes);
}
RVMMethod[] methods = type.asClass().getDeclaredMethods();
RVMMethod answer = null;
for (RVMMethod meth : methods) {
if (meth.getName() == aName && parametersMatch(meth.getParameterTypes(), parameterTypes)) {
if (answer == null) {
answer = meth;
} else {
RVMMethod m2 = meth;
if (answer.getReturnType().resolve().isAssignableFrom(m2.getReturnType().resolve())) {
answer = m2;
}
}
}
}
if (answer == null) {
throwNoSuchMethodException(name, parameterTypes);
}
return JikesRVMSupport.createMethod(answer);
}
public Class<?>[] getDeclaredClasses() throws SecurityException {
checkMemberAccess(Member.DECLARED);
if (!type.isClassType()) return new Class[0];
// Get array of declared classes from RVMClass object
RVMClass cls = type.asClass();
TypeReference[] declaredClasses = cls.getDeclaredClasses();
// The array can be null if the class has no declared inner class members
if (declaredClasses == null) return new Class[0];
// Count the number of actual declared inner and static classes.
// (The array may contain null elements, which we want to skip.)
int count = 0;
int length = declaredClasses.length;
for (int i = 0; i < length; ++i) {
if (declaredClasses[i] != null) {
++count;
}
}
// Now build actual result array.
Class<?>[] result = new Class[count];
count = 0;
for (int i = 0; i < length; ++i) {
if (declaredClasses[i] != null) {
result[count++] = declaredClasses[i].resolve().getClassForType();
}
}
return result;
}
public Method getMethod(String name, Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
checkMemberAccess(Member.PUBLIC);
if (!type.isClassType()) throwNoSuchMethodException(name, parameterTypes);
if (name == null) {
throwNoSuchMethodException(name, parameterTypes);
}
Atom aName = Atom.findOrCreateUnicodeAtom(name);
if (aName == RVMClassLoader.StandardClassInitializerMethodName
|| aName == RVMClassLoader.StandardObjectInitializerMethodName) {
// <init> and <clinit> are not methods.
throwNoSuchMethodException(name, parameterTypes);
}
// (1) Scan the declared public methods of this class and each of its superclasses
RVMMethod answer = getMethodInternal1(aName, parameterTypes);
if (answer == null) {
// (2) Now we need to consider methods inherited from interfaces.
// Because we inject the requisite Miranda methods, we can do this simply
// by looking at this class's virtual methods instead of searching interface hierarchies.
answer = getMethodInternal2(aName, parameterTypes);
}
if (answer == null) {
throwNoSuchMethodException(name, parameterTypes);
}
return JikesRVMSupport.createMethod(answer);
}
public Constructor<?>[] getDeclaredConstructors() throws SecurityException {
checkMemberAccess(Member.DECLARED);
if (!type.isClassType()) return new Constructor[0];
RVMMethod[] methods = type.asClass().getConstructorMethods();
Constructor<?>[] ans = new Constructor[methods.length];
for (int i = 0; i < methods.length; i++) {
ans[i] = JikesRVMSupport.createConstructor(methods[i]);
}
return ans;
}
public Field[] getDeclaredFields() throws SecurityException {
checkMemberAccess(Member.DECLARED);
if (!type.isClassType()) return new Field[0];
RVMField[] fields = type.asClass().getDeclaredFields();
Field[] ans = new Field[fields.length];
for (int i = 0; i < fields.length; i++) {
ans[i] = JikesRVMSupport.createField(fields[i]);
}
return ans;
}
public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException {
checkMemberAccess(Member.DECLARED);
if (!type.isClassType() || name == null) throwNoSuchFieldException(name);
Atom aName = Atom.findOrCreateUnicodeAtom(name);
RVMField answer = type.asClass().findDeclaredField(aName);
if (answer == null) {
throwNoSuchFieldException(name);
}
return JikesRVMSupport.createField(answer);
}
public Method[] getDeclaredMethods() throws SecurityException {
checkMemberAccess(Member.DECLARED);
if (!type.isClassType()) return new Method[0];
RVMMethod[] methods = type.asClass().getDeclaredMethods();
ArrayList<Method> coll = new ArrayList<Method>(methods.length);
for (RVMMethod meth : methods) {
if (!meth.isClassInitializer() && !meth.isObjectInitializer()) {
coll.add(JikesRVMSupport.createMethod(meth));
}
}
return coll.toArray(new Method[coll.size()]);
}
public Field getField(String name) throws NoSuchFieldException, SecurityException {
checkMemberAccess(Member.PUBLIC);
if (!type.isClassType()) throw new NoSuchFieldException();
Atom aName = Atom.findUnicodeAtom(name);
if (aName == null) throwNoSuchFieldException(name);
RVMField answer = getFieldInternal(aName);
if (answer == null) {
throwNoSuchFieldException(name);
}
return JikesRVMSupport.createField(answer);
}
public Constructor<?>[] getConstructors() throws SecurityException {
checkMemberAccess(Member.PUBLIC);
if (!type.isClassType()) return new Constructor[0];
RVMMethod[] methods = type.asClass().getConstructorMethods();
ArrayList<Constructor<T>> coll = new ArrayList<Constructor<T>>(methods.length);
for (RVMMethod method : methods) {
if (method.isPublic()) {
@SuppressWarnings("unchecked")
Constructor<T> x = (Constructor<T>) JikesRVMSupport.createConstructor(method);
coll.add(x);
}
}
return coll.toArray(new Constructor[coll.size()]);
}
public Method[] getMethods() throws SecurityException {
checkMemberAccess(Member.PUBLIC);
RVMMethod[] static_methods = type.getStaticMethods();
RVMMethod[] virtual_methods = type.getVirtualMethods();
ArrayList<Method> coll = new ArrayList<Method>(static_methods.length + virtual_methods.length);
for (RVMMethod meth : static_methods) {
if (meth.isPublic()) {
coll.add(JikesRVMSupport.createMethod(meth));
}
}
for (RVMMethod meth : virtual_methods) {
if (meth.isPublic()) {
coll.add(JikesRVMSupport.createMethod(meth));
}
}
return coll.toArray(new Method[coll.size()]);
}
public Field[] getFields() throws SecurityException {
checkMemberAccess(Member.PUBLIC);
RVMField[] static_fields = type.getStaticFields();
RVMField[] instance_fields = type.getInstanceFields();
ArrayList<Field> coll = new ArrayList<Field>(static_fields.length + instance_fields.length);
for (RVMField field : static_fields) {
if (field.isPublic()) {
coll.add(JikesRVMSupport.createField(field));
}
}
for (RVMField field : instance_fields) {
if (field.isPublic()) {
coll.add(JikesRVMSupport.createField(field));
}
}
return coll.toArray(new Field[coll.size()]);
}
@Inline(
value = Inline.When.ArgumentsAreConstant,
arguments = {0})
public T newInstance()
throws IllegalAccessException, InstantiationException, ExceptionInInitializerError,
SecurityException {
// Basic checks
checkMemberAccess(Member.PUBLIC);
if (!type.isClassType()) throw new InstantiationException();
RVMClass cls = type.asClass();
if (cls.isAbstract() || cls.isInterface()) throw new InstantiationException();
// Ensure that the class is initialized
if (!cls.isInitialized()) {
RuntimeEntrypoints.initializeClassForDynamicLink(cls);
}
// Find the defaultConstructor
RVMMethod defaultConstructor = getDefaultConstructor();
if (defaultConstructor == null) throw new InstantiationException();
// Check that caller is allowed to access it
if (!defaultConstructor.isPublic()) {
RVMClass accessingClass = RVMClass.getClassFromStackFrame(1);
VMCommonLibrarySupport.checkAccess(defaultConstructor, accessingClass);
}
// Allocate an uninitialized instance;
@SuppressWarnings("unchecked") // yes, we're giving an anonymous object a type.
T obj = (T) RuntimeEntrypoints.resolvedNewScalar(cls);
// Run the default constructor on the it.
Reflection.invoke(defaultConstructor, null, obj, null, true);
return obj;
}
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
checkMemberAccess(Member.DECLARED);
if (!type.isClassType()) throwNoSuchMethodException("<init>", parameterTypes);
RVMMethod answer = null;
if (parameterTypes == null || parameterTypes.length == 0) {
answer = getDefaultConstructor();
} else {
RVMMethod[] methods = type.asClass().getConstructorMethods();
for (RVMMethod method : methods) {
if (parametersMatch(method.getParameterTypes(), parameterTypes)) {
answer = method;
break;
}
}
}
if (answer == null) {
throwNoSuchMethodException("<init>", parameterTypes);
}
return JikesRVMSupport.createConstructor(answer);
}
public Class<?>[] getClasses() throws SecurityException {
checkMemberAccess(Member.PUBLIC);
if (!type.isClassType()) return new Class[0];
ArrayList<Class<?>> publicClasses = new ArrayList<Class<?>>();
for (Class<?> c = this; c != null; c = c.getSuperclass()) {
c.checkMemberAccess(Member.PUBLIC);
TypeReference[] declaredClasses = c.type.asClass().getDeclaredClasses();
if (declaredClasses != null) {
for (TypeReference declaredClass : declaredClasses) {
if (declaredClass != null) {
RVMClass dc = declaredClass.resolve().asClass();
if (dc.isPublic()) {
publicClasses.add(dc.getClassForType());
}
}
}
}
}
Class<?>[] result = new Class[publicClasses.size()];
result = publicClasses.toArray(result);
return result;
}