annotationClass);
/**
* Returns true if the annotation exists.
*/
native private boolean isDeclaredAnnotationPresent(Class annotationClass);
/**
* Returns an array containing {@code Class} objects for all classes and
* interfaces that are declared as members of the class which this {@code
* Class} represents. If there are no classes or interfaces declared or if
* this class represents an array class, a primitive type or void, then an
* empty array is returned.
*/
public Class[] getDeclaredClasses() {
return getDeclaredClasses(this, false);
}
/*
* Returns the list of member classes of the given class.
* If no members exist, an empty array is returned.
*/
private static native Class[] getDeclaredClasses(Class c, boolean publicOnly);
/**
* Returns a {@code Constructor} object which represents the constructor
* matching the given parameter types that is declared by the class
* represented by this {@code Class}.
* {@code (Class[]) null} is equivalent to the empty array.
*
* Use {@link #getConstructor} if you want to search superclasses.
*
* @throws NoSuchMethodException
* if the requested constructor can not be found.
*/
@SuppressWarnings("unchecked")
public Constructor getDeclaredConstructor(Class... parameterTypes)
throws NoSuchMethodException {
return (Constructor) getConstructorOrMethod("", false, false, parameterTypes);
}
/**
* Returns an array containing {@code Constructor} objects for all
* constructors declared in the class represented by this {@code Class}. If
* there are no constructors or if this {@code Class} represents an array
* class, a primitive type, or void then an empty array is returned.
*
* @see #getConstructors()
*/
public Constructor[] getDeclaredConstructors() {
return getDeclaredConstructors(this, false);
}
/*
* Returns the list of constructors. If no constructors exist, an empty array is returned.
*/
private static native Constructor[] getDeclaredConstructors(Class c,
boolean publicOnly);
/**
* Returns a {@code Field} object for the field with the given name
* which is declared in the class represented by this {@code Class}.
*
* @throws NoSuchFieldException if the requested field can not be found.
* @see #getField(String)
*/
public Field getDeclaredField(String name) throws NoSuchFieldException {
if (name == null) {
throw new NullPointerException("name == null");
}
Field result = getDeclaredField(this, name);
if (result == null) {
throw new NoSuchFieldException(name);
}
return result;
}
/**
* Returns an array containing {@code Field} objects for all fields declared
* in the class represented by this {@code Class}. If there are no fields or
* if this {@code Class} represents an array class, a primitive type or void
* then an empty array is returned.
*
* @see #getFields()
*/
public Field[] getDeclaredFields() {
return getDeclaredFields(this, false);
}
/*
* Returns the list of fields without performing any security checks
* first. If no fields exist at all, an empty array is returned.
*/
static native Field[] getDeclaredFields(Class c, boolean publicOnly);
/**
* Returns the field if it is defined by {@code c}; null otherwise. This
* may return a non-public member.
*/
static native Field getDeclaredField(Class c, String name);
/**
* Returns a {@code Method} object which represents the method matching the
* given name and parameter types that is declared by the class
* represented by this {@code Class}.
* {@code (Class[]) null} is equivalent to the empty array.
*
* See {@link #getMethod} if you want to search superclasses.
*
* @throws NoSuchMethodException
* if the requested method can not be found.
* @throws NullPointerException
* if {@code name} is {@code null}.
*/
public Method getDeclaredMethod(String name, Class... parameterTypes)
throws NoSuchMethodException {
Member member = getConstructorOrMethod(name, false, false, parameterTypes);
if (member instanceof Constructor) {
throw new NoSuchMethodException(name);
}
return (Method) member;
}
/**
* Returns an array containing {@code Method} objects for all methods
* declared in the class represented by this {@code Class}. If there are no
* methods or if this {@code Class} represents an array class, a primitive
* type or void then an empty array is returned.
*
* @see #getMethods()
*/
public Method[] getDeclaredMethods() {
return getDeclaredMethods(this, false);
}
/**
* Returns the list of methods. If no methods exist, an empty array is returned.
*/
static native Method[] getDeclaredMethods(Class c, boolean publicOnly);
/**
* Returns the constructor or method if it is defined by {@code c}; null
* otherwise. This may return a non-public member. Use "" to get a constructor.
*/
static native Member getDeclaredConstructorOrMethod(Class c, String name, Class[] args);
/**
* Returns the declaring {@code Class} of this {@code Class}. Returns
* {@code null} if the class is not a member of another class or if this
* {@code Class} represents an array class, a primitive type, or void.
*/
public native Class getDeclaringClass();
/**
* Returns the enclosing {@code Class} of this {@code Class}. If there is no
* enclosing class the method returns {@code null}.
*/
public native Class getEnclosingClass();
/**
* Returns the enclosing {@code Constructor} of this {@code Class}, if it is an
* anonymous or local/automatic class; otherwise {@code null}.
*/
public native Constructor getEnclosingConstructor();
/**
* Returns the enclosing {@code Method} of this {@code Class}, if it is an
* anonymous or local/automatic class; otherwise {@code null}.
*/
public native Method getEnclosingMethod();
/**
* Returns the {@code enum} constants associated with this {@code Class}.
* Returns {@code null} if this {@code Class} does not represent an {@code
* enum} type.
*/
@SuppressWarnings("unchecked") // we only cast after confirming that this class is an enum
public T[] getEnumConstants() {
if (!isEnum()) {
return null;
}
return (T[]) Enum.getSharedConstants((Class) this).clone();
}
/**
* Returns a {@code Field} object which represents the public field with the
* given name. This method first searches the class C represented by
* this {@code Class}, then the interfaces implemented by C and finally the
* superclasses of C.
*
* @throws NoSuchFieldException
* if the field can not be found.
* @see #getDeclaredField(String)
*/
public Field getField(String name) throws NoSuchFieldException {
if (name == null) {
throw new NullPointerException("name == null");
}
Field result = getPublicFieldRecursive(name);
if (result == null) {
throw new NoSuchFieldException(name);
}
return result;
}
private Field getPublicFieldRecursive(String name) {
// search superclasses
for (Class c = this; c != null; c = c.getSuperclass()) {
Field result = Class.getDeclaredField(c, name);
if (result != null && (result.getModifiers() & Modifier.PUBLIC) != 0) {
return result;
}
}
// search implemented interfaces
for (Class c = this; c != null; c = c.getSuperclass()) {
for (Class ifc : c.getInterfaces()) {
Field result = ifc.getPublicFieldRecursive(name);
if (result != null && (result.getModifiers() & Modifier.PUBLIC) != 0) {
return result;
}
}
}
return null;
}
/**
* Returns an array containing {@code Field} objects for all public fields
* for the class C represented by this {@code Class}. Fields may be declared
* in C, the interfaces it implements or in the superclasses of C. The
* elements in the returned array are in no particular order.
*
* If there are no public fields or if this class represents an array class,
* a primitive type or {@code void} then an empty array is returned.
*
* @see #getDeclaredFields()
*/
public Field[] getFields() {
List fields = new ArrayList();
getPublicFieldsRecursive(fields);
/*
* The result may include duplicates when this class implements an interface
* through multiple paths. Remove those duplicates.
*/
CollectionUtils.removeDuplicates(fields, Field.ORDER_BY_NAME_AND_DECLARING_CLASS);
return fields.toArray(new Field[fields.size()]);
}
/**
* Populates {@code result} with public fields defined by this class, its
* superclasses, and all implemented interfaces.
*/
private void getPublicFieldsRecursive(List result) {
// search superclasses
for (Class c = this; c != null; c = c.getSuperclass()) {
for (Field field : Class.getDeclaredFields(c, true)) {
result.add(field);
}
}
// search implemented interfaces
for (Class c = this; c != null; c = c.getSuperclass()) {
for (Class ifc : c.getInterfaces()) {
ifc.getPublicFieldsRecursive(result);
}
}
}
/**
* Returns the {@link Type}s of the interfaces that this {@code Class} directly
* implements. If the {@code Class} represents a primitive type or {@code
* void} then an empty array is returned.
*/
public Type[] getGenericInterfaces() {
Type[] result;
synchronized (Caches.genericInterfaces) {
result = Caches.genericInterfaces.get(this);
if (result == null) {
String annotationSignature = AnnotationAccess.getSignature(this);
if (annotationSignature == null) {
result = getInterfaces();
} else {
GenericSignatureParser parser = new GenericSignatureParser(getClassLoader());
parser.parseForClass(this, annotationSignature);
result = Types.getTypeArray(parser.interfaceTypes, false);
}
Caches.genericInterfaces.put(this, result);
}
}
return (result.length == 0) ? result : result.clone();
}
/**
* Returns the {@code Type} that represents the superclass of this {@code
* class}.
*/
public Type getGenericSuperclass() {
Type genericSuperclass = getSuperclass();
String annotationSignature = AnnotationAccess.getSignature(this);
if (annotationSignature != null) {
GenericSignatureParser parser = new GenericSignatureParser(getClassLoader());
parser.parseForClass(this, annotationSignature);
genericSuperclass = parser.superclassType;
}
return Types.getType(genericSuperclass);
}
/**
* Returns an array of {@code Class} objects that match the interfaces
* in the {@code implements} declaration of the class represented
* by this {@code Class}. The order of the elements in the array is
* identical to the order in the original class declaration. If the class
* does not implement any interfaces, an empty array is returned.
*/
public native Class[] getInterfaces();
/**
* Returns a {@code Method} object which represents the public method with
* the given name and parameter types.
* {@code (Class[]) null} is equivalent to the empty array.
*
* This method first searches the class C represented by this {@code Class},
* then the superclasses of C,
* and finally the interfaces implemented by C and its superclasses.
*
*
Use {@link #getDeclaredMethod} if you don't want to search superclasses.
*
* @throws NoSuchMethodException
* if the method can not be found.
*/
public Method getMethod(String name, Class... parameterTypes) throws NoSuchMethodException {
Member member = getConstructorOrMethod(name, true, true, parameterTypes);
if (member instanceof Constructor) {
throw new NoSuchMethodException(name);
}
return (Method) member;
}
/**
* Returns an array containing {@code Method} objects for all public methods
* for the class C represented by this {@code Class}. Methods may be
* declared in C, the interfaces it implements or in the superclasses of C.
* The elements in the returned array are in no particular order.
*
*
If there are no public methods or if this {@code Class} represents a
* primitive type or {@code void} then an empty array is returned.
*
* @see #getDeclaredMethods()
*/
public Method[] getMethods() {
List methods = new ArrayList();
getPublicMethodsRecursive(methods);
/*
* Remove methods defined by multiple types, preferring to keep methods
* declared by derived types.
*/
CollectionUtils.removeDuplicates(methods, Method.ORDER_BY_SIGNATURE);
return methods.toArray(new Method[methods.size()]);
}
/**
* Populates {@code result} with public methods defined by this class, its
* superclasses, and all implemented interfaces, including overridden methods.
*/
private void getPublicMethodsRecursive(List result) {
// search superclasses
for (Class c = this; c != null; c = c.getSuperclass()) {
for (Method method : Class.getDeclaredMethods(c, true)) {
result.add(method);
}
}
// search implemented interfaces
for (Class c = this; c != null; c = c.getSuperclass()) {
for (Class ifc : c.getInterfaces()) {
ifc.getPublicMethodsRecursive(result);
}
}
}
/**
* Returns an integer that represents the modifiers of the class represented
* by this {@code Class}. The returned value is a combination of bits
* defined by constants in the {@link Modifier} class.
*/
public int getModifiers() {
return getModifiers(this, false);
}
/*
* Returns the modifiers for the given class.
*
* {@code ignoreInnerClassesAttrib} determines whether we look for and use the
* flags from an "inner class" attribute
*/
private static native int getModifiers(Class clazz, boolean ignoreInnerClassesAttrib);
/**
* Returns the name of the class represented by this {@code Class}. For a
* description of the format which is used, see the class definition of
* {@link Class}.
*/
public String getName() {
String result = name;
return (result == null) ? (name = getNameNative()) : result;
}
private native String getNameNative();
/**
* Returns the simple name of the class represented by this {@code Class} as
* defined in the source code. If there is no name (that is, the class is
* anonymous) then an empty string is returned. If the receiver is an array
* then the name of the underlying type with square braces appended (for
* example {@code "Integer[]"}) is returned.
*
* @return the simple name of the class represented by this {@code Class}.
*/
public String getSimpleName() {
if (isArray()) {
return getComponentType().getSimpleName() + "[]";
}
String name = getName();
if (isAnonymousClass()) {
return "";
}
if (isMemberClass() || isLocalClass()) {
return getInnerClassName();
}
int dot = name.lastIndexOf('.');
if (dot != -1) {
return name.substring(dot + 1);
}
return name;
}
/*
* Returns the simple name of a member or local class, or null otherwise.
*/
private native String getInnerClassName();
/**
* Returns null.
*/
public ProtectionDomain getProtectionDomain() {
return null;
}
/**
* Returns the URL of the given resource, or null if the resource is not found.
* The mapping between the resource name and the URL is managed by the class' class loader.
*
* @see ClassLoader
*/
public URL getResource(String resourceName) {
// Get absolute resource name, but without the leading slash
if (resourceName.startsWith("/")) {
resourceName = resourceName.substring(1);
} else {
String pkg = getName();
int dot = pkg.lastIndexOf('.');
if (dot != -1) {
pkg = pkg.substring(0, dot).replace('.', '/');
} else {
pkg = "";
}
resourceName = pkg + "/" + resourceName;
}
// Delegate to proper class loader
ClassLoader loader = getClassLoader();
if (loader != null) {
return loader.getResource(resourceName);
} else {
return ClassLoader.getSystemResource(resourceName);
}
}
/**
* Returns a read-only stream for the contents of the given resource, or null if the resource
* is not found.
* The mapping between the resource name and the stream is managed by the class' class loader.
*
* @see ClassLoader
*/
public InputStream getResourceAsStream(String resourceName) {
// Get absolute resource name, but without the leading slash
if (resourceName.startsWith("/")) {
resourceName = resourceName.substring(1);
} else {
String pkg = getName();
int dot = pkg.lastIndexOf('.');
if (dot != -1) {
pkg = pkg.substring(0, dot).replace('.', '/');
} else {
pkg = "";
}
resourceName = pkg + "/" + resourceName;
}
// Delegate to proper class loader
ClassLoader loader = getClassLoader();
if (loader != null) {
return loader.getResourceAsStream(resourceName);
} else {
return ClassLoader.getSystemResourceAsStream(resourceName);
}
}
/**
* Returns null. (On Android, a {@code ClassLoader} can load classes from multiple dex files.
* All classes from any given dex file will have the same signers, but different dex
* files may have different signers. This does not fit well with the original
* {@code ClassLoader}-based model of {@code getSigners}.)
*/
public Object[] getSigners() {
// See http://code.google.com/p/android/issues/detail?id=1766.
return null;
}
/**
* Returns the {@code Class} object which represents the superclass of the
* class represented by this {@code Class}. If this {@code Class} represents
* the {@code Object} class, a primitive type, an interface or void then the
* method returns {@code null}. If this {@code Class} represents an array
* class then the {@code Object} class is returned.
*/
public native Class getSuperclass();
/**
* Returns an array containing {@code TypeVariable} objects for type
* variables declared by the generic class represented by this {@code
* Class}. Returns an empty array if the class is not generic.
*/
@SuppressWarnings("unchecked")
public synchronized TypeVariable>[] getTypeParameters() {
String annotationSignature = AnnotationAccess.getSignature(this);
if (annotationSignature == null) {
return EmptyArray.TYPE_VARIABLE;
}
GenericSignatureParser parser = new GenericSignatureParser(getClassLoader());
parser.parseForClass(this, annotationSignature);
return parser.formalTypeParameters;
}
/**
* Tests whether this {@code Class} represents an annotation class.
*/
public boolean isAnnotation() {
final int ACC_ANNOTATION = 0x2000; // not public in reflect.Modifiers
int mod = getModifiers(this, true);
return (mod & ACC_ANNOTATION) != 0;
}
@Override public boolean isAnnotationPresent(Class annotationType) {
if (annotationType == null) {
throw new NullPointerException("annotationType == null");
}
if (isDeclaredAnnotationPresent(annotationType)) {
return true;
}
if (annotationType.isDeclaredAnnotationPresent(Inherited.class)) {
for (Class sup = getSuperclass(); sup != null; sup = sup.getSuperclass()) {
if (sup.isDeclaredAnnotationPresent(annotationType)) {
return true;
}
}
}
return false;
}
/**
* Tests whether the class represented by this {@code Class} is
* anonymous.
*/
native public boolean isAnonymousClass();
/**
* Tests whether the class represented by this {@code Class} is an array class.
*/
public boolean isArray() {
return getComponentType() != null;
}
/**
* Tests whether the given class type can be converted to the class
* represented by this {@code Class}. Conversion may be done via an identity
* conversion or a widening reference conversion (if either the receiver or
* the argument represent primitive types, only the identity conversion
* applies).
*
* @throws NullPointerException
* if {@code c} is {@code null}.
*/
public native boolean isAssignableFrom(Class c);
/**
* Tests whether the class represented by this {@code Class} is an
* {@code enum}.
*/
public boolean isEnum() {
if (getSuperclass() != Enum.class) {
return false;
}
int mod = getModifiers(this, true);
return (mod & 0x4000) != 0;
}
/**
* Tests whether the given object can be cast to the class
* represented by this {@code Class}. This is the runtime version of the
* {@code instanceof} operator.
*
* @return {@code true} if {@code object} can be cast to the type
* represented by this {@code Class}; {@code false} if {@code
* object} is {@code null} or cannot be cast.
*/
public native boolean isInstance(Object object);
/**
* Tests whether this {@code Class} represents an interface.
*/
public native boolean isInterface();
/**
* Tests whether the class represented by this {@code Class} is defined
* locally.
*/
public boolean isLocalClass() {
boolean enclosed = (getEnclosingMethod() != null ||
getEnclosingConstructor() != null);
return enclosed && !isAnonymousClass();
}
/**
* Tests whether the class represented by this {@code Class} is a member
* class.
*/
public boolean isMemberClass() {
return getDeclaringClass() != null;
}
/**
* Tests whether this {@code Class} represents a primitive type.
*/
public native boolean isPrimitive();
/**
* Tests whether this {@code Class} represents a synthetic type.
*/
public boolean isSynthetic() {
final int ACC_SYNTHETIC = 0x1000; // not public in reflect.Modifiers
int mod = getModifiers(this, true);
return (mod & ACC_SYNTHETIC) != 0;
}
/**
* Returns a new instance of the class represented by this {@code Class},
* created by invoking the default (that is, zero-argument) constructor. If
* there is no such constructor, or if the creation fails (either because of
* a lack of available memory or because an exception is thrown by the
* constructor), an {@code InstantiationException} is thrown. If the default
* constructor exists but is not accessible from the context where this
* method is invoked, an {@code IllegalAccessException} is thrown.
*
* @throws IllegalAccessException
* if the default constructor is not visible.
* @throws InstantiationException
* if the instance can not be created.
*/
public T newInstance() throws InstantiationException, IllegalAccessException {
return newInstanceImpl();
}
private native T newInstanceImpl() throws IllegalAccessException, InstantiationException;
@Override
public String toString() {
if (isPrimitive()) {
return getSimpleName();
}
return (isInterface() ? "interface " : "class ") + getName();
}
/**
* Returns the {@code Package} of which the class represented by this
* {@code Class} is a member. Returns {@code null} if no {@code Package}
* object was created by the class loader of the class.
*/
public Package getPackage() {
// TODO This might be a hack, but the VM doesn't have the necessary info.
ClassLoader loader = getClassLoader();
if (loader != null) {
String name = getName();
int dot = name.lastIndexOf('.');
return (dot != -1 ? loader.getPackage(name.substring(0, dot)) : null);
}
return null;
}
/**
* Returns the assertion status for the class represented by this {@code
* Class}. Assertion is enabled / disabled based on the class loader,
* package or class default at runtime.
*/
public native boolean desiredAssertionStatus();
/**
* Casts this {@code Class} to represent a subclass of the given class.
* If successful, this {@code Class} is returned; otherwise a {@code
* ClassCastException} is thrown.
*
* @throws ClassCastException
* if this {@code Class} cannot be cast to the given type.
*/
@SuppressWarnings("unchecked")
public Class asSubclass(Class c) {
if (c.isAssignableFrom(this)) {
return (Class)this;
}
String actualClassName = this.getName();
String desiredClassName = c.getName();
throw new ClassCastException(actualClassName + " cannot be cast to " + desiredClassName);
}
/**
* Casts the given object to the type represented by this {@code Class}.
* If the object is {@code null} then the result is also {@code null}.
*
* @throws ClassCastException
* if the object cannot be cast to the given type.
*/
@SuppressWarnings("unchecked")
public T cast(Object obj) {
if (obj == null) {
return null;
} else if (this.isInstance(obj)) {
return (T)obj;
}
String actualClassName = obj.getClass().getName();
String desiredClassName = this.getName();
throw new ClassCastException(actualClassName + " cannot be cast to " + desiredClassName);
}
/**
* Copies two arrays into one. Assumes that the destination array is large
* enough.
*
* @param result the destination array
* @param head the first source array
* @param tail the second source array
* @return the destination array, that is, result
*/
private static T[] arraycopy(T[] result, T[] head, T[] tail) {
System.arraycopy(head, 0, result, 0, head.length);
System.arraycopy(tail, 0, result, head.length, tail.length);
return result;
}
/**
* The annotation directory offset of this class in its own Dex, or 0 if it
* is unknown.
*
* TODO: 0 is a sentinel that means 'no annotations directory'; this should be -1 if unknown
*
* @hide
*/
public int getDexAnnotationDirectoryOffset() {
Dex dex = getDex();
if (dex == null) {
return 0;
}
int classDefIndex = getDexClassDefIndex();
if (classDefIndex < 0) {
return 0;
}
return dex.annotationDirectoryOffsetFromClassDefIndex(classDefIndex);
}
/**
* Returns a resolved type from the dex cache, computing the type from the dex file if
* necessary.
* TODO: use Dalvik's dex cache.
* @hide
*/
public Class getDexCacheType(Dex dex, int typeIndex) {
String internalName = dex.typeNames().get(typeIndex);
return InternalNames.getClass(getClassLoader(), internalName);
}
/**
* Returns a string from the dex cache, computing the string from the dex file if necessary.
*
* @hide
*/
public String getDexCacheString(Dex dex, int dexStringIndex) {
return dex.strings().get(dexStringIndex);
}
private static class Caches {
/**
* Cache to avoid frequent recalculation of generic interfaces, which is generally uncommon.
* Sized sufficient to allow ConcurrentHashMapTest to run without recalculating its generic
* interfaces (required to avoid time outs). Validated by running reflection heavy code
* such as applications using Guice-like frameworks.
*/
private static final BasicLruCache genericInterfaces
= new BasicLruCache(8);
}
}